Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

test: delete 45 news shadow tests that test inline reproductions, not SUT (#4242)

LearningCircuitf1c23f603faf
diff --git a/tests/news/test_api_client_patterns_behavior.py b/tests/news/test_api_client_patterns_behavior.py
deleted file mode 100644
index 48cb00a5e8..0000000000
--- a/tests/news/test_api_client_patterns_behavior.py
+++ /dev/null
@@ -1,960 +0,0 @@
-"""
-Behavioral tests for API client patterns.
-
-These tests verify the logic of API client patterns like request building,
-response parsing, header management, authentication, and error handling
-without making actual HTTP requests.
-"""
-
-import base64
-import hashlib
-import hmac
-import json
-import time
-import urllib.parse
-from dataclasses import dataclass
-
-
-class TestRequestBuilding:
- """Tests for building HTTP requests."""
-
- def test_build_get_request(self):
- """Test building a GET request."""
-
- def build_request(method, url, params=None):
- request = {"method": method, "url": url}
- if params:
- query = urllib.parse.urlencode(params)
- request["url"] = f"{url}?{query}"
- return request
-
- request = build_request(
- "GET", "https://api.example.com/users", {"page": 1}
- )
- assert request["method"] == "GET"
- assert "page=1" in request["url"]
-
- def test_build_post_request_with_json_body(self):
- """Test building a POST request with JSON body."""
-
- def build_request(
- method, url, body=None, content_type="application/json"
- ):
- request = {"method": method, "url": url, "headers": {}}
- if body:
- request["body"] = json.dumps(body)
- request["headers"]["Content-Type"] = content_type
- return request
-
- request = build_request(
- "POST",
- "https://api.example.com/users",
- {"name": "John", "email": "[email protected]"},
- )
- assert request["method"] == "POST"
- assert request["headers"]["Content-Type"] == "application/json"
- body = json.loads(request["body"])
- assert body["name"] == "John"
-
- def test_build_request_with_path_params(self):
- """Test building request with path parameters."""
-
- def build_url(template, path_params):
- url = template
- for key, value in path_params.items():
- url = url.replace(f"{{{key}}}", str(value))
- return url
-
- url = build_url(
- "https://api.example.com/users/{user_id}/posts/{post_id}",
- {"user_id": 123, "post_id": 456},
- )
- assert url == "https://api.example.com/users/123/posts/456"
-
- def test_encode_query_params(self):
- """Test encoding query parameters."""
-
- def encode_params(params):
- return urllib.parse.urlencode(params, doseq=True)
-
- # Simple params
- assert encode_params({"a": 1, "b": 2}) == "a=1&b=2"
-
- # Special characters
- encoded = encode_params({"query": "hello world"})
- assert "hello+world" in encoded or "hello%20world" in encoded
-
- # List values
- encoded = encode_params({"tags": ["a", "b", "c"]})
- assert "tags=a" in encoded and "tags=b" in encoded
-
- def test_build_multipart_form_data(self):
- """Test building multipart form data."""
-
- def build_multipart(fields, boundary="----boundary"):
- parts = []
- for name, value in fields.items():
- part = f'--{boundary}\r\nContent-Disposition: form-data; name="{name}"\r\n\r\n{value}\r\n'
- parts.append(part)
- parts.append(f"--{boundary}--\r\n")
- return "".join(parts)
-
- result = build_multipart({"name": "John", "age": "30"})
- assert 'name="name"' in result
- assert "John" in result
- assert 'name="age"' in result
- assert "30" in result
-
-
-class TestResponseParsing:
- """Tests for parsing HTTP responses."""
-
- def test_parse_json_response(self):
- """Test parsing JSON response."""
-
- def parse_response(body, content_type):
- if "application/json" in content_type:
- return json.loads(body)
- return body
-
- result = parse_response('{"id": 1, "name": "John"}', "application/json")
- assert result["id"] == 1
- assert result["name"] == "John"
-
- def test_parse_paginated_response(self):
- """Test parsing paginated response."""
-
- @dataclass
- class PaginatedResponse:
- data: list
- page: int
- total_pages: int
- total_items: int
- has_next: bool
- has_prev: bool
-
- def parse_paginated(response):
- return PaginatedResponse(
- data=response.get("data", []),
- page=response.get("page", 1),
- total_pages=response.get("total_pages", 1),
- total_items=response.get("total", 0),
- has_next=response.get("page", 1)
- < response.get("total_pages", 1),
- has_prev=response.get("page", 1) > 1,
- )
-
- result = parse_paginated(
- {"data": [1, 2, 3], "page": 2, "total_pages": 5, "total": 50}
- )
- assert result.data == [1, 2, 3]
- assert result.page == 2
- assert result.has_next is True
- assert result.has_prev is True
-
- def test_extract_links_from_response(self):
- """Test extracting links from response headers."""
-
- def parse_link_header(header):
- links = {}
- if not header:
- return links
- for part in header.split(","):
- match = part.strip()
- if "<" in match and ">" in match:
- url = match[match.index("<") + 1 : match.index(">")]
- if 'rel="' in match:
- rel_start = match.index('rel="') + 5
- rel_end = match.index('"', rel_start)
- rel = match[rel_start:rel_end]
- links[rel] = url
- return links
-
- header = '<https://api.example.com/users?page=2>; rel="next", <https://api.example.com/users?page=10>; rel="last"'
- links = parse_link_header(header)
- assert links["next"] == "https://api.example.com/users?page=2"
- assert links["last"] == "https://api.example.com/users?page=10"
-
- def test_handle_empty_response(self):
- """Test handling empty response."""
-
- def parse_response(body, status_code):
- if status_code == 204 or not body:
- return None
- return json.loads(body)
-
- assert parse_response("", 204) is None
- assert parse_response("", 200) is None
- assert parse_response('{"ok": true}', 200) == {"ok": True}
-
- def test_parse_error_response(self):
- """Test parsing error response."""
-
- @dataclass
- class APIError:
- status: int
- code: str
- message: str
- details: dict
-
- def parse_error(body, status_code):
- try:
- data = json.loads(body)
- return APIError(
- status=status_code,
- code=data.get("error", {}).get("code", "unknown"),
- message=data.get("error", {}).get(
- "message", "Unknown error"
- ),
- details=data.get("error", {}).get("details", {}),
- )
- except json.JSONDecodeError:
- return APIError(
- status=status_code,
- code="parse_error",
- message=body,
- details={},
- )
-
- error = parse_error(
- '{"error": {"code": "not_found", "message": "User not found"}}', 404
- )
- assert error.status == 404
- assert error.code == "not_found"
- assert error.message == "User not found"
-
-
-class TestHeaderManagement:
- """Tests for HTTP header management."""
-
- def test_set_default_headers(self):
- """Test setting default headers."""
-
- def get_default_headers(api_key=None, user_agent="MyClient/1.0"):
- headers = {
- "Accept": "application/json",
- "User-Agent": user_agent,
- }
- if api_key:
- headers["Authorization"] = f"Bearer {api_key}"
- return headers
-
- headers = get_default_headers("secret123")
- assert headers["Accept"] == "application/json"
- assert headers["Authorization"] == "Bearer secret123"
- assert headers["User-Agent"] == "MyClient/1.0"
-
- def test_merge_headers(self):
- """Test merging headers with precedence."""
-
- def merge_headers(default_headers, custom_headers):
- result = default_headers.copy()
- result.update(custom_headers)
- return result
-
- default = {"Accept": "application/json", "User-Agent": "Client/1.0"}
- custom = {"Accept": "text/html", "X-Custom": "value"}
- merged = merge_headers(default, custom)
- assert merged["Accept"] == "text/html" # Custom overrides
- assert merged["User-Agent"] == "Client/1.0" # Default preserved
- assert merged["X-Custom"] == "value" # Custom added
-
- def test_parse_response_headers(self):
- """Test parsing response headers."""
-
- def get_rate_limit_info(headers):
- return {
- "limit": int(headers.get("X-RateLimit-Limit", 0)),
- "remaining": int(headers.get("X-RateLimit-Remaining", 0)),
- "reset": int(headers.get("X-RateLimit-Reset", 0)),
- }
-
- headers = {
- "X-RateLimit-Limit": "100",
- "X-RateLimit-Remaining": "95",
- "X-RateLimit-Reset": "1609459200",
- }
- info = get_rate_limit_info(headers)
- assert info["limit"] == 100
- assert info["remaining"] == 95
-
- def test_content_type_detection(self):
- """Test content type detection."""
-
- def get_content_type(body):
- if isinstance(body, dict) or isinstance(body, list):
- return "application/json"
- if isinstance(body, str) and body.startswith("<?xml"):
- return "application/xml"
- if isinstance(body, bytes):
- return "application/octet-stream"
- return "text/plain"
-
- assert get_content_type({"key": "value"}) == "application/json"
- assert get_content_type('<?xml version="1.0"?>') == "application/xml"
- assert get_content_type(b"binary") == "application/octet-stream"
- assert get_content_type("hello") == "text/plain"
-
- def test_accept_header_negotiation(self):
- """Test Accept header content negotiation."""
-
- def negotiate_content_type(accept_header, available_types):
- # Parse Accept header and return best match
- if not accept_header or accept_header == "*/*":
- return available_types[0] if available_types else None
-
- preferences = []
- for part in accept_header.split(","):
- part = part.strip()
- quality = 1.0
- if ";q=" in part:
- type_part, q_part = part.split(";q=")
- quality = float(q_part)
- part = type_part.strip()
- preferences.append((part, quality))
-
- preferences.sort(key=lambda x: x[1], reverse=True)
-
- for pref_type, _ in preferences:
- if pref_type in available_types:
- return pref_type
- return None
-
- available = ["application/json", "application/xml", "text/html"]
- assert (
- negotiate_content_type("application/json", available)
- == "application/json"
- )
- assert (
- negotiate_content_type(
- "application/xml;q=0.9, application/json;q=1.0", available
- )
- == "application/json"
- )
-
-
-class TestAuthentication:
- """Tests for API authentication patterns."""
-
- def test_basic_auth_header(self):
- """Test Basic authentication header generation."""
-
- def basic_auth_header(username, password):
- credentials = f"{username}:{password}"
- encoded = base64.b64encode(credentials.encode()).decode()
- return f"Basic {encoded}"
-
- header = basic_auth_header("user", "pass")
- assert header.startswith("Basic ")
- decoded = base64.b64decode(header.split(" ")[1]).decode()
- assert decoded == "user:pass"
-
- def test_bearer_token_header(self):
- """Test Bearer token header generation."""
-
- def bearer_auth_header(token):
- return f"Bearer {token}"
-
- header = bearer_auth_header("eyJhbGciOiJIUzI1NiIs...")
- assert header == "Bearer eyJhbGciOiJIUzI1NiIs..."
-
- def test_api_key_auth(self):
- """Test API key authentication."""
-
- def api_key_auth(api_key, location="header", param_name="X-API-Key"):
- if location == "header":
- return {"headers": {param_name: api_key}}
- if location == "query":
- return {"params": {param_name: api_key}}
- return {}
-
- header_auth = api_key_auth("secret123", "header")
- assert header_auth["headers"]["X-API-Key"] == "secret123"
-
- query_auth = api_key_auth("secret123", "query", "api_key")
- assert query_auth["params"]["api_key"] == "secret123"
-
- def test_hmac_signature(self):
- """Test HMAC signature generation."""
-
- def generate_signature(secret, message):
- key = secret.encode()
- msg = message.encode()
- return hmac.new(key, msg, hashlib.sha256).hexdigest()
-
- sig1 = generate_signature(
- "secret", "message"
- ) # DevSkim: ignore DS126858 - uses SHA-256
- sig2 = generate_signature(
- "secret", "message"
- ) # DevSkim: ignore DS126858 - uses SHA-256
- sig3 = generate_signature("other", "message")
- assert sig1 == sig2 # Same input = same signature
- assert sig1 != sig3 # Different secret = different signature
- assert len(sig1) == 64 # SHA256 hex = 64 chars
-
- def test_oauth_token_refresh_check(self):
- """Test OAuth token refresh check."""
-
- def should_refresh_token(expires_at, buffer_seconds=300):
- if not expires_at:
- return False
- now = time.time()
- return now >= (expires_at - buffer_seconds)
-
- # Token expires in 10 seconds - should refresh
- assert should_refresh_token(time.time() + 10) is True
-
- # Token expires in 10 minutes - no need to refresh
- assert should_refresh_token(time.time() + 600) is False
-
- # Token already expired - should refresh
- assert should_refresh_token(time.time() - 10) is True
-
-
-class TestRetryLogic:
- """Tests for API retry logic."""
-
- def test_should_retry_status_code(self):
- """Test determining if status code should trigger retry."""
-
- def should_retry(status_code, retry_codes=None):
- if retry_codes is None:
- retry_codes = {408, 429, 500, 502, 503, 504}
- return status_code in retry_codes
-
- assert should_retry(429) is True # Rate limited
- assert should_retry(503) is True # Service unavailable
- assert should_retry(404) is False # Not found - no retry
- assert should_retry(400) is False # Bad request - no retry
-
- def test_calculate_retry_delay(self):
- """Test calculating retry delay with backoff."""
-
- def calculate_delay(
- attempt, base_delay=1.0, max_delay=60.0, multiplier=2.0
- ):
- delay = base_delay * (multiplier ** (attempt - 1))
- return min(delay, max_delay)
-
- assert calculate_delay(1) == 1.0
- assert calculate_delay(2) == 2.0
- assert calculate_delay(3) == 4.0
- assert calculate_delay(10) == 60.0 # Capped at max
-
- def test_respect_retry_after_header(self):
- """Test respecting Retry-After header."""
-
- def get_retry_delay(headers, default_delay=1.0):
- retry_after = headers.get("Retry-After")
- if retry_after:
- try:
- return float(retry_after)
- except ValueError:
- # Could be HTTP date format, use default
- pass
- return default_delay
-
- assert get_retry_delay({"Retry-After": "30"}) == 30.0
- assert get_retry_delay({}) == 1.0
- assert get_retry_delay({"Retry-After": "invalid"}) == 1.0
-
- def test_max_retries_exceeded(self):
- """Test max retries check."""
-
- def can_retry(attempt, max_retries=3):
- return attempt < max_retries
-
- assert can_retry(1, max_retries=3) is True
- assert can_retry(2, max_retries=3) is True
- assert can_retry(3, max_retries=3) is False
- assert can_retry(4, max_retries=3) is False
-
- def test_idempotent_method_check(self):
- """Test checking if method is idempotent for retry."""
-
- def is_idempotent(method):
- return method.upper() in {"GET", "HEAD", "PUT", "DELETE", "OPTIONS"}
-
- assert is_idempotent("GET") is True
- assert is_idempotent("PUT") is True
- assert is_idempotent("POST") is False # Not idempotent by default
-
-
-class TestURLBuilding:
- """Tests for URL building and manipulation."""
-
- def test_join_url_parts(self):
- """Test joining URL parts."""
-
- def join_url(base, *parts):
- url = base.rstrip("/")
- for part in parts:
- url = f"{url}/{part.strip('/')}"
- return url
-
- assert (
- join_url("https://api.example.com", "users", "123")
- == "https://api.example.com/users/123"
- )
- assert (
- join_url("https://api.example.com/", "/users/", "/123/")
- == "https://api.example.com/users/123"
- )
-
- def test_add_query_params(self):
- """Test adding query parameters to URL."""
-
- def add_params(url, params):
- if not params:
- return url
- query = urllib.parse.urlencode(params)
- separator = "&" if "?" in url else "?"
- return f"{url}{separator}{query}"
-
- assert (
- add_params("https://api.example.com/users", {"page": 1})
- == "https://api.example.com/users?page=1"
- )
- assert (
- add_params(
- "https://api.example.com/users?status=active", {"page": 1}
- )
- == "https://api.example.com/users?status=active&page=1"
- )
-
- def test_parse_url_components(self):
- """Test parsing URL components."""
-
- def parse_url(url):
- parsed = urllib.parse.urlparse(url)
- return {
- "scheme": parsed.scheme,
- "host": parsed.netloc,
- "path": parsed.path,
- "query": dict(urllib.parse.parse_qsl(parsed.query)),
- }
-
- result = parse_url("https://api.example.com/users?page=1&limit=10")
- assert result["scheme"] == "https"
- assert result["host"] == "api.example.com"
- assert result["path"] == "/users"
- assert result["query"]["page"] == "1"
- assert result["query"]["limit"] == "10"
-
- def test_url_template_expansion(self):
- """Test URL template expansion."""
-
- def expand_template(template, variables):
- result = template
- for key, value in variables.items():
- result = result.replace(
- f"{{{key}}}", urllib.parse.quote(str(value))
- )
- return result
-
- template = "https://api.example.com/users/{id}/posts/{post_id}"
- result = expand_template(template, {"id": 123, "post_id": 456})
- assert result == "https://api.example.com/users/123/posts/456"
-
- def test_encode_special_characters(self):
- """Test encoding special characters in URL."""
-
- def safe_encode(value):
- return urllib.parse.quote(str(value), safe="")
-
- assert safe_encode("hello world") == "hello%20world"
- assert safe_encode("a+b") == "a%2Bb"
- assert safe_encode("a/b") == "a%2Fb"
-
-
-class TestRequestValidation:
- """Tests for request validation."""
-
- def test_validate_required_params(self):
- """Test validating required parameters."""
-
- def validate_required(params, required_fields):
- missing = [
- f
- for f in required_fields
- if f not in params or params[f] is None
- ]
- return missing
-
- missing = validate_required({"name": "John"}, ["name", "email"])
- assert missing == ["email"]
-
- missing = validate_required(
- {"name": "John", "email": "[email protected]"}, ["name", "email"]
- )
- assert missing == []
-
- def test_validate_param_types(self):
- """Test validating parameter types."""
-
- def validate_types(params, type_spec):
- errors = []
- for field, expected_type in type_spec.items():
- if field in params:
- value = params[field]
- if not isinstance(value, expected_type):
- errors.append(
- f"{field}: expected {expected_type.__name__}"
- )
- return errors
-
- errors = validate_types(
- {"name": "John", "age": "thirty"}, {"name": str, "age": int}
- )
- assert len(errors) == 1
- assert "age" in errors[0]
-
- def test_validate_param_range(self):
- """Test validating parameter value range."""
-
- def validate_range(value, min_val=None, max_val=None):
- if min_val is not None and value < min_val:
- return f"Value must be >= {min_val}"
- if max_val is not None and value > max_val:
- return f"Value must be <= {max_val}"
- return None
-
- assert validate_range(5, min_val=1, max_val=10) is None
- assert validate_range(0, min_val=1) == "Value must be >= 1"
- assert validate_range(15, max_val=10) == "Value must be <= 10"
-
- def test_sanitize_request_params(self):
- """Test sanitizing request parameters."""
-
- def sanitize_params(params, strip_none=True, trim_strings=True):
- result = {}
- for key, value in params.items():
- if strip_none and value is None:
- continue
- if trim_strings and isinstance(value, str):
- value = value.strip()
- result[key] = value
- return result
-
- params = {"name": " John ", "email": None, "age": 30}
- sanitized = sanitize_params(params)
- assert sanitized == {"name": "John", "age": 30}
-
- def test_validate_content_length(self):
- """Test validating content length."""
-
- def validate_content_length(body, max_size=1024 * 1024):
- if body is None:
- return None
- size = len(body.encode() if isinstance(body, str) else body)
- if size > max_size:
- return f"Content too large: {size} > {max_size}"
- return None
-
- assert validate_content_length("small body") is None
- assert validate_content_length("x" * 2_000_000) is not None
-
-
-class TestResponseCaching:
- """Tests for response caching logic."""
-
- def test_is_cacheable_response(self):
- """Test determining if response is cacheable."""
-
- def is_cacheable(status_code, method, cache_control=None):
- if method not in {"GET", "HEAD"}:
- return False
- if status_code not in {200, 203, 204, 206, 300, 301, 404, 410}:
- return False
- if cache_control:
- if "no-store" in cache_control or "no-cache" in cache_control:
- return False
- return True
-
- assert is_cacheable(200, "GET") is True
- assert is_cacheable(200, "POST") is False
- assert is_cacheable(500, "GET") is False
- assert is_cacheable(200, "GET", "no-store") is False
-
- def test_parse_cache_control_header(self):
- """Test parsing Cache-Control header."""
-
- def parse_cache_control(header):
- directives = {}
- for part in header.split(","):
- part = part.strip()
- if "=" in part:
- key, value = part.split("=", 1)
- directives[key.strip()] = value.strip()
- else:
- directives[part] = True
- return directives
-
- result = parse_cache_control("max-age=3600, public, no-transform")
- assert result["max-age"] == "3600"
- assert result["public"] is True
- assert result["no-transform"] is True
-
- def test_calculate_cache_expiry(self):
- """Test calculating cache expiry time."""
-
- def calculate_expiry(headers, default_ttl=300):
- cache_control = headers.get("Cache-Control", "")
- if "max-age=" in cache_control:
- for part in cache_control.split(","):
- if "max-age=" in part:
- max_age = int(part.split("=")[1].strip())
- return time.time() + max_age
- return time.time() + default_ttl
-
- headers = {"Cache-Control": "max-age=3600"}
- expiry = calculate_expiry(headers)
- assert expiry > time.time() + 3500
-
- def test_generate_cache_key(self):
- """Test generating cache key."""
-
- def generate_cache_key(method, url, params=None, vary_headers=None):
- parts = [method.upper(), url]
- if params:
- parts.append(json.dumps(params, sort_keys=True))
- if vary_headers:
- parts.append(json.dumps(vary_headers, sort_keys=True))
- key_string = "|".join(parts)
- return hashlib.sha256(key_string.encode()).hexdigest()
-
- key1 = generate_cache_key("GET", "/api/users", {"page": 1})
- key2 = generate_cache_key("GET", "/api/users", {"page": 1})
- key3 = generate_cache_key(
- "GET", "/api/users", {"page": 2}
- ) # DevSkim: ignore DS126858
- assert key1 == key2 # Same request = same key
- assert key1 != key3 # Different params = different key
-
- def test_should_revalidate(self):
- """Test checking if cache should be revalidated."""
-
- def should_revalidate(cached_at, max_age, stale_while_revalidate=0):
- age = time.time() - cached_at
- if age <= max_age:
- return False # Still fresh
- if age <= max_age + stale_while_revalidate:
- return True # Stale but can serve while revalidating
- return True # Must revalidate
-
- now = time.time()
- # Fresh - no revalidation needed
- assert should_revalidate(now - 100, 300) is False
- # Expired - revalidation needed
- assert should_revalidate(now - 400, 300) is True
-
-
-class TestTimeoutHandling:
- """Tests for timeout handling."""
-
- def test_calculate_timeout(self):
- """Test calculating request timeout."""
-
- def calculate_timeout(operation, default_timeout=30):
- timeouts = {
- "read": 30,
- "write": 60,
- "upload": 300,
- "download": 300,
- }
- return timeouts.get(operation, default_timeout)
-
- assert calculate_timeout("read") == 30
- assert calculate_timeout("upload") == 300
- assert calculate_timeout("unknown") == 30
-
- def test_adjust_timeout_for_content_size(self):
- """Test adjusting timeout based on content size."""
-
- def adjust_timeout(base_timeout, content_size, bytes_per_second=50000):
- if content_size <= 0:
- return base_timeout
- estimated_time = content_size / bytes_per_second
- return max(base_timeout, estimated_time * 1.5)
-
- # Small content - use base timeout
- assert adjust_timeout(30, 1000) == 30
-
- # Large content - increase timeout
- timeout = adjust_timeout(30, 5_000_000)
- assert timeout > 30
-
- def test_timeout_budget(self):
- """Test timeout budget tracking."""
-
- @dataclass
- class TimeoutBudget:
- total: float
- started_at: float
- spent: float = 0.0
-
- def remaining(self):
- elapsed = time.time() - self.started_at
- return max(0, self.total - elapsed - self.spent)
-
- def spend(self, amount):
- self.spent += amount
-
- budget = TimeoutBudget(total=30.0, started_at=time.time())
- assert budget.remaining() > 25 # Should have most time remaining
- budget.spend(10.0)
- assert budget.remaining() < 20
-
-
-class TestWebhookHandling:
- """Tests for webhook handling patterns."""
-
- def test_verify_webhook_signature(self):
- """Test verifying webhook signature."""
-
- def verify_signature(payload, signature, secret, algorithm="sha256"):
- if algorithm == "sha256":
- expected = hmac.new(
- secret.encode(), payload.encode(), hashlib.sha256
- ).hexdigest()
- else:
- return False
- return hmac.compare_digest(signature, expected)
-
- payload = '{"event": "test"}'
- secret = "webhook_secret"
- valid_sig = hmac.new(
- secret.encode(), payload.encode(), hashlib.sha256
- ).hexdigest()
-
- assert verify_signature(payload, valid_sig, secret) is True
- assert verify_signature(payload, "invalid", secret) is False
-
- def test_parse_webhook_event(self):
- """Test parsing webhook event."""
-
- @dataclass
- class WebhookEvent:
- event_type: str
- timestamp: str
- payload: dict
-
- def parse_webhook(body):
- data = json.loads(body)
- return WebhookEvent(
- event_type=data.get("type", "unknown"),
- timestamp=data.get("timestamp", ""),
- payload=data.get("data", {}),
- )
-
- body = '{"type": "user.created", "timestamp": "2024-01-01T00:00:00Z", "data": {"id": 123}}'
- event = parse_webhook(body)
- assert event.event_type == "user.created"
- assert event.payload["id"] == 123
-
- def test_deduplicate_webhook(self):
- """Test webhook deduplication."""
-
- class WebhookDeduplicator:
- def __init__(self):
- self.processed_ids = set()
-
- def is_duplicate(self, event_id):
- if event_id in self.processed_ids:
- return True
- self.processed_ids.add(event_id)
- return False
-
- dedup = WebhookDeduplicator()
- assert dedup.is_duplicate("event_1") is False
- assert dedup.is_duplicate("event_1") is True # Duplicate
- assert dedup.is_duplicate("event_2") is False
-
-
-class TestBatchRequests:
- """Tests for batch request patterns."""
-
- def test_chunk_requests(self):
- """Test chunking requests into batches."""
-
- def chunk_requests(items, batch_size=100):
- return [
- items[i : i + batch_size]
- for i in range(0, len(items), batch_size)
- ]
-
- items = list(range(250))
- batches = chunk_requests(items, 100)
- assert len(batches) == 3
- assert len(batches[0]) == 100
- assert len(batches[1]) == 100
- assert len(batches[2]) == 50
-
- def test_build_batch_request(self):
- """Test building a batch request."""
-
- def build_batch_request(requests):
- return {
- "batch": [
- {"id": str(i), "method": r["method"], "url": r["url"]}
- for i, r in enumerate(requests)
- ]
- }
-
- requests = [
- {"method": "GET", "url": "/users/1"},
- {"method": "GET", "url": "/users/2"},
- ]
- batch = build_batch_request(requests)
- assert len(batch["batch"]) == 2
- assert batch["batch"][0]["id"] == "0"
-
- def test_parse_batch_response(self):
- """Test parsing batch response."""
-
- def parse_batch_response(response):
- results = {}
- for item in response.get("responses", []):
- results[item["id"]] = {
- "status": item["status"],
- "body": item.get("body"),
- }
- return results
-
- response = {
- "responses": [
- {"id": "0", "status": 200, "body": {"name": "John"}},
- {"id": "1", "status": 404, "body": None},
- ]
- }
- results = parse_batch_response(response)
- assert results["0"]["status"] == 200
- assert results["1"]["status"] == 404
-
- def test_aggregate_batch_errors(self):
- """Test aggregating batch errors."""
-
- def aggregate_errors(results):
- errors = []
- for request_id, result in results.items():
- if result["status"] >= 400:
- errors.append(
- {
- "request_id": request_id,
- "status": result["status"],
- "message": result.get("body", {}).get(
- "error", "Unknown"
- ),
- }
- )
- return errors
-
- results = {
- "0": {"status": 200, "body": {}},
- "1": {"status": 404, "body": {"error": "Not found"}},
- "2": {"status": 500, "body": {"error": "Server error"}},
- }
- errors = aggregate_errors(results)
- assert len(errors) == 2
- assert errors[0]["status"] == 404
diff --git a/tests/news/test_api_helpers_logic_behavior.py b/tests/news/test_api_helpers_logic_behavior.py
deleted file mode 100644
index 8b9f6e24be..0000000000
--- a/tests/news/test_api_helpers_logic_behavior.py
+++ /dev/null
@@ -1,442 +0,0 @@
-"""
-Deep behavioral tests for api.py helper logic patterns.
-Tests response structure building, parameter validation,
-error handling, and list/pagination patterns.
-"""
-
-
-# --- Success response structure ---
-
-
-class TestSuccessResponseStructure:
- """Tests for success response dictionary structure."""
-
- def _build_success_response(self, data, message=None):
- response = {"success": True, "data": data}
- if message:
- response["message"] = message
- return response
-
- def test_has_success_true(self):
- response = self._build_success_response({})
- assert response["success"] is True
-
- def test_has_data(self):
- response = self._build_success_response({"items": []})
- assert response["data"]["items"] == []
-
- def test_optional_message(self):
- response = self._build_success_response({}, "Operation completed")
- assert response["message"] == "Operation completed"
-
- def test_no_message_if_not_provided(self):
- response = self._build_success_response({})
- assert "message" not in response
-
-
-# --- Error response structure ---
-
-
-class TestErrorResponseStructure:
- """Tests for error response dictionary structure."""
-
- def _build_error_response(self, error_message, error_code=None):
- response = {"success": False, "error": error_message}
- if error_code:
- response["error_code"] = error_code
- return response
-
- def test_has_success_false(self):
- response = self._build_error_response("Error")
- assert response["success"] is False
-
- def test_has_error_message(self):
- response = self._build_error_response("Something went wrong")
- assert response["error"] == "Something went wrong"
-
- def test_optional_error_code(self):
- response = self._build_error_response("Error", "INVALID_INPUT")
- assert response["error_code"] == "INVALID_INPUT"
-
-
-# --- List response structure ---
-
-
-class TestListResponseStructure:
- """Tests for list response with pagination."""
-
- def _build_list_response(self, items, total, offset, limit):
- return {
- "success": True,
- "data": {
- "items": items,
- "total": total,
- "offset": offset,
- "limit": limit,
- "has_more": offset + len(items) < total,
- },
- }
-
- def test_includes_items(self):
- response = self._build_list_response([1, 2, 3], 10, 0, 3)
- assert response["data"]["items"] == [1, 2, 3]
-
- def test_includes_total(self):
- response = self._build_list_response([1, 2], 50, 0, 10)
- assert response["data"]["total"] == 50
-
- def test_has_more_true(self):
- response = self._build_list_response([1, 2], 10, 0, 2)
- assert response["data"]["has_more"] is True
-
- def test_has_more_false(self):
- response = self._build_list_response([1, 2], 2, 0, 10)
- assert response["data"]["has_more"] is False
-
-
-# --- Limit validation ---
-
-
-class TestLimitValidation:
- """Tests for limit parameter validation."""
-
- def _validate_limit(self, limit, min_val=1, max_val=100):
- if limit < min_val:
- raise ValueError(f"Limit must be at least {min_val}")
- if limit > max_val:
- return max_val
- return limit
-
- def test_valid_limit(self):
- assert self._validate_limit(10) == 10
-
- def test_limit_below_min_raises(self):
- try:
- self._validate_limit(0)
- assert False, "Should raise ValueError"
- except ValueError:
- pass
-
- def test_limit_capped_at_max(self):
- assert self._validate_limit(500) == 100
-
-
-# --- Offset validation ---
-
-
-class TestOffsetValidation:
- """Tests for offset parameter validation."""
-
- def _validate_offset(self, offset):
- if offset < 0:
- return 0
- return offset
-
- def test_valid_offset(self):
- assert self._validate_offset(10) == 10
-
- def test_negative_offset_clamped(self):
- assert self._validate_offset(-5) == 0
-
-
-# --- User ID extraction ---
-
-
-class TestUserIdExtraction:
- """Tests for extracting user ID from session."""
-
- def _get_user_id(self, session, default="anonymous"):
- return session.get("user_id") or session.get("username") or default
-
- def test_from_user_id(self):
- session = {"user_id": "user123"}
- assert self._get_user_id(session) == "user123"
-
- def test_from_username_fallback(self):
- session = {"username": "alice"}
- assert self._get_user_id(session) == "alice"
-
- def test_default_anonymous(self):
- session = {}
- assert self._get_user_id(session) == "anonymous"
-
-
-# --- Subscription type validation ---
-
-
-class TestSubscriptionTypeValidation:
- """Tests for subscription type validation."""
-
- VALID_TYPES = ["search", "topic"]
-
- def _is_valid_type(self, sub_type):
- return sub_type in self.VALID_TYPES
-
- def test_search_valid(self):
- assert self._is_valid_type("search") is True
-
- def test_topic_valid(self):
- assert self._is_valid_type("topic") is True
-
- def test_invalid_type(self):
- assert self._is_valid_type("unknown") is False
-
-
-# --- Status validation ---
-
-
-class TestStatusValidation:
- """Tests for subscription status validation."""
-
- VALID_STATUSES = ["active", "paused", "expired"]
-
- def _is_valid_status(self, status):
- return status in self.VALID_STATUSES
-
- def test_active_valid(self):
- assert self._is_valid_status("active") is True
-
- def test_paused_valid(self):
- assert self._is_valid_status("paused") is True
-
- def test_expired_valid(self):
- assert self._is_valid_status("expired") is True
-
- def test_invalid_status(self):
- assert self._is_valid_status("deleted") is False
-
-
-# --- Refresh interval validation ---
-
-
-class TestRefreshIntervalValidation:
- """Tests for refresh interval validation."""
-
- MIN_INTERVAL = 15 # 15 minutes
- MAX_INTERVAL = 10080 # 1 week
-
- def _validate_interval(self, interval):
- if interval < self.MIN_INTERVAL:
- return self.MIN_INTERVAL
- if interval > self.MAX_INTERVAL:
- return self.MAX_INTERVAL
- return interval
-
- def test_valid_interval(self):
- assert self._validate_interval(60) == 60
-
- def test_below_min_clamped(self):
- assert self._validate_interval(5) == 15
-
- def test_above_max_clamped(self):
- assert self._validate_interval(20000) == 10080
-
-
-# --- Query string validation ---
-
-
-class TestQueryStringValidation:
- """Tests for query string validation."""
-
- def _is_valid_query(self, query):
- return query and len(query.strip()) >= 3
-
- def test_valid_query(self):
- assert self._is_valid_query("AI news") is True
-
- def test_short_query_invalid(self):
- assert self._is_valid_query("AI") is False
-
- def test_empty_query_invalid(self):
- assert not self._is_valid_query("")
-
- def test_whitespace_only_invalid(self):
- assert self._is_valid_query(" ") is False
-
-
-# --- Subscription create response ---
-
-
-class TestSubscriptionCreateResponse:
- """Tests for subscription creation response."""
-
- def _build_create_response(self, subscription_id, query_or_topic, sub_type):
- return {
- "success": True,
- "data": {
- "subscription_id": subscription_id,
- "query_or_topic": query_or_topic,
- "subscription_type": sub_type,
- "status": "active",
- },
- "message": f"{sub_type.title()} subscription created successfully",
- }
-
- def test_has_subscription_id(self):
- response = self._build_create_response("sub-123", "AI", "topic")
- assert response["data"]["subscription_id"] == "sub-123"
-
- def test_status_active(self):
- response = self._build_create_response("sub-123", "AI", "topic")
- assert response["data"]["status"] == "active"
-
- def test_message_includes_type(self):
- response = self._build_create_response("sub-123", "AI", "search")
- assert "Search" in response["message"]
-
-
-# --- Subscription delete response ---
-
-
-class TestSubscriptionDeleteResponse:
- """Tests for subscription deletion response."""
-
- def _build_delete_response(self, subscription_id):
- return {
- "success": True,
- "data": {"subscription_id": subscription_id, "deleted": True},
- "message": "Subscription deleted successfully",
- }
-
- def test_deleted_true(self):
- response = self._build_delete_response("sub-123")
- assert response["data"]["deleted"] is True
-
-
-# --- Feed response structure ---
-
-
-class TestFeedResponseStructure:
- """Tests for feed response structure."""
-
- def _build_feed_response(self, cards, total, user_id):
- return {
- "success": True,
- "data": {
- "cards": cards,
- "total": total,
- "user_id": user_id,
- },
- }
-
- def test_has_cards(self):
- response = self._build_feed_response([{"id": "1"}], 1, "user")
- assert len(response["data"]["cards"]) == 1
-
- def test_has_user_id(self):
- response = self._build_feed_response([], 0, "user123")
- assert response["data"]["user_id"] == "user123"
-
-
-# --- Preferences response structure ---
-
-
-class TestPreferencesResponseStructure:
- """Tests for preferences response structure."""
-
- def _build_preferences_response(self, user_id, preferences):
- return {
- "success": True,
- "data": {"user_id": user_id, "preferences": preferences},
- }
-
- def test_has_preferences(self):
- prefs = {"liked_categories": ["Tech"]}
- response = self._build_preferences_response("u1", prefs)
- assert response["data"]["preferences"]["liked_categories"] == ["Tech"]
-
-
-# --- Rating response structure ---
-
-
-class TestRatingResponseStructure:
- """Tests for rating response structure."""
-
- def _build_rating_response(self, card_id, rating_type, value):
- return {
- "success": True,
- "data": {
- "card_id": card_id,
- "rating_type": rating_type,
- "value": value,
- },
- "message": "Rating recorded",
- }
-
- def test_has_rating_value(self):
- response = self._build_rating_response("c1", "relevance", 1)
- assert response["data"]["value"] == 1
-
-
-# --- Feature disabled response ---
-
-
-class TestFeatureDisabledResponse:
- """Tests for feature disabled response."""
-
- def _build_disabled_response(self, feature):
- return {
- "success": False,
- "error": f"{feature} is disabled",
- "error_code": "FEATURE_DISABLED",
- }
-
- def test_error_message(self):
- response = self._build_disabled_response("News")
- assert "disabled" in response["error"]
-
- def test_error_code(self):
- response = self._build_disabled_response("News")
- assert response["error_code"] == "FEATURE_DISABLED"
-
-
-# --- Not found response ---
-
-
-class TestNotFoundResponse:
- """Tests for not found response."""
-
- def _build_not_found_response(self, resource_type, resource_id):
- return {
- "success": False,
- "error": f"{resource_type} not found: {resource_id}",
- "error_code": "NOT_FOUND",
- }
-
- def test_error_includes_id(self):
- response = self._build_not_found_response("Subscription", "sub-123")
- assert "sub-123" in response["error"]
-
- def test_error_code_not_found(self):
- response = self._build_not_found_response("Card", "c1")
- assert response["error_code"] == "NOT_FOUND"
-
-
-# --- Batch operation response ---
-
-
-class TestBatchOperationResponse:
- """Tests for batch operation response."""
-
- def _build_batch_response(self, total, successful, failed):
- return {
- "success": failed == 0,
- "data": {
- "total": total,
- "successful": successful,
- "failed": failed,
- },
- }
-
- def test_all_successful(self):
- response = self._build_batch_response(10, 10, 0)
- assert response["success"] is True
-
- def test_some_failed(self):
- response = self._build_batch_response(10, 8, 2)
- assert response["success"] is False
-
- def test_counts_correct(self):
- response = self._build_batch_response(10, 7, 3)
- assert response["data"]["successful"] == 7
- assert response["data"]["failed"] == 3
diff --git a/tests/news/test_api_response_patterns_behavior.py b/tests/news/test_api_response_patterns_behavior.py
deleted file mode 100644
index 0aef137211..0000000000
--- a/tests/news/test_api_response_patterns_behavior.py
+++ /dev/null
@@ -1,600 +0,0 @@
-"""
-Deep behavioral tests for API response building patterns.
-Tests response structure construction, error formatting,
-pagination patterns, and data transformation logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-
-
-# --- Success response patterns ---
-
-
-class TestSuccessResponsePattern:
- """Tests for success response construction."""
-
- def _success(self, data, message=None):
- response = {"success": True, "data": data}
- if message:
- response["message"] = message
- return response
-
- def test_always_has_success_true(self):
- response = self._success({})
- assert response["success"] is True
-
- def test_includes_data(self):
- response = self._success({"items": [1, 2, 3]})
- assert response["data"]["items"] == [1, 2, 3]
-
- def test_optional_message(self):
- response = self._success({}, "Operation completed")
- assert response["message"] == "Operation completed"
-
- def test_no_message_key_when_not_provided(self):
- response = self._success({})
- assert "message" not in response
-
- def test_nested_data(self):
- response = self._success({"user": {"id": "1", "name": "test"}})
- assert response["data"]["user"]["name"] == "test"
-
- def test_empty_data(self):
- response = self._success({})
- assert response["data"] == {}
-
- def test_list_data(self):
- response = self._success([1, 2, 3])
- assert response["data"] == [1, 2, 3]
-
-
-# --- Error response patterns ---
-
-
-class TestErrorResponsePattern:
- """Tests for error response construction."""
-
- def _error(self, message, code=None, details=None):
- response = {"success": False, "error": message}
- if code:
- response["error_code"] = code
- if details:
- response["details"] = details
- return response
-
- def test_always_has_success_false(self):
- response = self._error("Error message")
- assert response["success"] is False
-
- def test_includes_error_message(self):
- response = self._error("Something went wrong")
- assert response["error"] == "Something went wrong"
-
- def test_optional_error_code(self):
- response = self._error("Error", "INVALID_INPUT")
- assert response["error_code"] == "INVALID_INPUT"
-
- def test_no_code_key_when_not_provided(self):
- response = self._error("Error")
- assert "error_code" not in response
-
- def test_optional_details(self):
- response = self._error("Error", details={"field": "name"})
- assert response["details"]["field"] == "name"
-
-
-class TestHTTPErrorCodes:
- """Tests for HTTP error code patterns."""
-
- def test_400_bad_request(self):
- error = {"code": 400, "message": "Bad request"}
- assert error["code"] == 400
-
- def test_401_unauthorized(self):
- error = {"code": 401, "message": "Unauthorized"}
- assert error["code"] == 401
-
- def test_403_forbidden(self):
- error = {"code": 403, "message": "Forbidden"}
- assert error["code"] == 403
-
- def test_404_not_found(self):
- error = {"code": 404, "message": "Not found"}
- assert error["code"] == 404
-
- def test_409_conflict(self):
- error = {"code": 409, "message": "Conflict"}
- assert error["code"] == 409
-
- def test_500_internal_error(self):
- error = {"code": 500, "message": "Internal server error"}
- assert error["code"] == 500
-
-
-# --- List response patterns ---
-
-
-class TestListResponsePattern:
- """Tests for list response with pagination."""
-
- def _list_response(self, items, total, offset=0, limit=50):
- return {
- "success": True,
- "data": {
- "items": items,
- "total": total,
- "offset": offset,
- "limit": limit,
- "has_more": offset + len(items) < total,
- },
- }
-
- def test_includes_items(self):
- response = self._list_response([1, 2, 3], 3)
- assert response["data"]["items"] == [1, 2, 3]
-
- def test_includes_total(self):
- response = self._list_response([1, 2], 10)
- assert response["data"]["total"] == 10
-
- def test_includes_offset(self):
- response = self._list_response([1, 2], 10, offset=5)
- assert response["data"]["offset"] == 5
-
- def test_includes_limit(self):
- response = self._list_response([1, 2], 10, limit=20)
- assert response["data"]["limit"] == 20
-
- def test_has_more_true(self):
- response = self._list_response([1, 2], 10, offset=0)
- assert response["data"]["has_more"] is True
-
- def test_has_more_false_all_items(self):
- response = self._list_response([1, 2, 3], 3)
- assert response["data"]["has_more"] is False
-
- def test_has_more_false_last_page(self):
- response = self._list_response([9, 10], 10, offset=8)
- assert response["data"]["has_more"] is False
-
- def test_empty_items(self):
- response = self._list_response([], 0)
- assert response["data"]["items"] == []
- assert response["data"]["has_more"] is False
-
-
-# --- Subscription response patterns ---
-
-
-class TestSubscriptionResponsePattern:
- """Tests for subscription-specific response patterns."""
-
- def _format_subscription(self, sub):
- return {
- "id": sub["id"],
- "name": sub.get("name") or "",
- "query_or_topic": sub["query_or_topic"],
- "subscription_type": sub["subscription_type"],
- "refresh_interval_minutes": sub.get("refresh_interval_minutes", 60),
- "is_active": sub.get("status") == "active",
- "status": sub.get("status", "active"),
- "next_refresh": sub.get("next_refresh"),
- "last_refresh": sub.get("last_refresh"),
- "created_at": sub.get("created_at"),
- }
-
- def test_includes_id(self):
- sub = {
- "id": "sub-123",
- "query_or_topic": "AI",
- "subscription_type": "topic",
- }
- result = self._format_subscription(sub)
- assert result["id"] == "sub-123"
-
- def test_name_defaults_empty(self):
- sub = {"id": "1", "query_or_topic": "AI", "subscription_type": "topic"}
- result = self._format_subscription(sub)
- assert result["name"] == ""
-
- def test_is_active_from_status(self):
- sub = {
- "id": "1",
- "query_or_topic": "AI",
- "subscription_type": "topic",
- "status": "active",
- }
- result = self._format_subscription(sub)
- assert result["is_active"] is True
-
- def test_not_active_when_paused(self):
- sub = {
- "id": "1",
- "query_or_topic": "AI",
- "subscription_type": "topic",
- "status": "paused",
- }
- result = self._format_subscription(sub)
- assert result["is_active"] is False
-
- def test_default_refresh_interval(self):
- sub = {"id": "1", "query_or_topic": "AI", "subscription_type": "topic"}
- result = self._format_subscription(sub)
- assert result["refresh_interval_minutes"] == 60
-
-
-# --- Card response patterns ---
-
-
-class TestCardResponsePattern:
- """Tests for card-specific response patterns."""
-
- def _format_card(self, card):
- return {
- "id": card["id"],
- "card_type": card.get("card_type", "news"),
- "headline": card.get("headline", ""),
- "summary": card.get("summary", ""),
- "category": card.get("category", "General"),
- "impact_score": card.get("impact_score", 5),
- "created_at": card.get("created_at"),
- "topics": card.get("topics", []),
- "source": card.get("source", {}),
- }
-
- def test_includes_id(self):
- card = {"id": "card-123"}
- result = self._format_card(card)
- assert result["id"] == "card-123"
-
- def test_default_card_type(self):
- card = {"id": "1"}
- result = self._format_card(card)
- assert result["card_type"] == "news"
-
- def test_default_impact_score(self):
- card = {"id": "1"}
- result = self._format_card(card)
- assert result["impact_score"] == 5
-
- def test_default_category(self):
- card = {"id": "1"}
- result = self._format_card(card)
- assert result["category"] == "General"
-
- def test_topics_defaults_empty(self):
- card = {"id": "1"}
- result = self._format_card(card)
- assert result["topics"] == []
-
-
-# --- Feed response patterns ---
-
-
-class TestFeedResponsePattern:
- """Tests for feed-specific response patterns."""
-
- def _format_feed(self, cards, user_id, total, filters=None):
- return {
- "success": True,
- "data": {
- "cards": cards,
- "total": total,
- "user_id": user_id,
- "filters": filters or {},
- },
- }
-
- def test_includes_cards(self):
- response = self._format_feed([{"id": "1"}], "u1", 1)
- assert len(response["data"]["cards"]) == 1
-
- def test_includes_user_id(self):
- response = self._format_feed([], "user-123", 0)
- assert response["data"]["user_id"] == "user-123"
-
- def test_includes_total(self):
- response = self._format_feed([{}, {}], "u1", 10)
- assert response["data"]["total"] == 10
-
- def test_includes_filters(self):
- filters = {"category": "Tech"}
- response = self._format_feed([], "u1", 0, filters)
- assert response["data"]["filters"]["category"] == "Tech"
-
- def test_empty_filters_default(self):
- response = self._format_feed([], "u1", 0)
- assert response["data"]["filters"] == {}
-
-
-# --- Stats response patterns ---
-
-
-class TestStatsResponsePattern:
- """Tests for statistics response patterns."""
-
- def _format_stats(self, subscriptions, votes_up, votes_down, views):
- return {
- "success": True,
- "data": {
- "subscriptions": subscriptions,
- "votes_up": votes_up,
- "votes_down": votes_down,
- "total_views": views,
- },
- }
-
- def test_includes_subscriptions(self):
- response = self._format_stats(5, 10, 2, 100)
- assert response["data"]["subscriptions"] == 5
-
- def test_includes_votes(self):
- response = self._format_stats(0, 15, 3, 0)
- assert response["data"]["votes_up"] == 15
- assert response["data"]["votes_down"] == 3
-
- def test_includes_views(self):
- response = self._format_stats(0, 0, 0, 500)
- assert response["data"]["total_views"] == 500
-
-
-# --- Scheduler status response patterns ---
-
-
-class TestSchedulerStatusResponsePattern:
- """Tests for scheduler status response patterns."""
-
- def _format_scheduler_status(
- self, is_running, active_users, total_jobs, config=None
- ):
- return {
- "success": True,
- "data": {
- "scheduler_available": True,
- "is_running": is_running,
- "active_users": active_users,
- "total_scheduled_jobs": total_jobs,
- "config": config or {},
- },
- }
-
- def test_scheduler_always_available(self):
- response = self._format_scheduler_status(False, 0, 0)
- assert response["data"]["scheduler_available"] is True
-
- def test_is_running_reflected(self):
- response = self._format_scheduler_status(True, 0, 0)
- assert response["data"]["is_running"] is True
-
- def test_active_users_count(self):
- response = self._format_scheduler_status(True, 5, 0)
- assert response["data"]["active_users"] == 5
-
- def test_total_jobs_count(self):
- response = self._format_scheduler_status(True, 0, 15)
- assert response["data"]["total_scheduled_jobs"] == 15
-
-
-# --- Folder response patterns ---
-
-
-class TestFolderResponsePattern:
- """Tests for folder response patterns."""
-
- def _format_folder(self, folder, subscription_count=0):
- return {
- "id": folder["id"],
- "name": folder["name"],
- "description": folder.get("description", ""),
- "created_at": folder.get("created_at"),
- "subscription_count": subscription_count,
- }
-
- def test_includes_id_and_name(self):
- folder = {"id": "f1", "name": "My Folder"}
- result = self._format_folder(folder)
- assert result["id"] == "f1"
- assert result["name"] == "My Folder"
-
- def test_description_defaults_empty(self):
- folder = {"id": "f1", "name": "Test"}
- result = self._format_folder(folder)
- assert result["description"] == ""
-
- def test_includes_subscription_count(self):
- folder = {"id": "f1", "name": "Test"}
- result = self._format_folder(folder, subscription_count=10)
- assert result["subscription_count"] == 10
-
-
-# --- Rating response patterns ---
-
-
-class TestRatingResponsePattern:
- """Tests for rating response patterns."""
-
- def _format_rating_response(self, card_id, rating_type, value):
- return {
- "success": True,
- "data": {
- "card_id": card_id,
- "rating_type": rating_type,
- "value": value,
- },
- "message": "Rating recorded",
- }
-
- def test_includes_card_id(self):
- response = self._format_rating_response("card-123", "relevance", "up")
- assert response["data"]["card_id"] == "card-123"
-
- def test_includes_rating_type(self):
- response = self._format_rating_response("c1", "relevance", "up")
- assert response["data"]["rating_type"] == "relevance"
-
- def test_includes_value(self):
- response = self._format_rating_response("c1", "relevance", "up")
- assert response["data"]["value"] == "up"
-
- def test_has_confirmation_message(self):
- response = self._format_rating_response("c1", "relevance", "up")
- assert response["message"] == "Rating recorded"
-
-
-# --- Batch operation response patterns ---
-
-
-class TestBatchOperationResponsePattern:
- """Tests for batch operation response patterns."""
-
- def _format_batch_result(self, total, successful, failed, errors=None):
- return {
- "success": failed == 0,
- "data": {
- "total": total,
- "successful": successful,
- "failed": failed,
- "errors": errors or [],
- },
- }
-
- def test_all_successful(self):
- response = self._format_batch_result(10, 10, 0)
- assert response["success"] is True
-
- def test_partial_failure(self):
- response = self._format_batch_result(10, 7, 3)
- assert response["success"] is False
-
- def test_includes_counts(self):
- response = self._format_batch_result(10, 8, 2)
- assert response["data"]["total"] == 10
- assert response["data"]["successful"] == 8
- assert response["data"]["failed"] == 2
-
- def test_includes_errors(self):
- errors = [{"id": "1", "error": "Failed"}]
- response = self._format_batch_result(1, 0, 1, errors)
- assert len(response["data"]["errors"]) == 1
-
-
-# --- Datetime formatting patterns ---
-
-
-class TestDatetimeFormatting:
- """Tests for datetime formatting in responses."""
-
- def test_iso_format(self):
- dt = datetime(2025, 6, 15, 12, 30, 0, tzinfo=timezone.utc)
- formatted = dt.isoformat()
- assert "2025-06-15" in formatted
-
- def test_iso_format_has_timezone(self):
- dt = datetime.now(timezone.utc)
- formatted = dt.isoformat()
- assert "+" in formatted or "Z" in formatted or "-" in formatted
-
- def test_relative_time_ago(self):
- now = datetime.now(timezone.utc)
- past = now - timedelta(hours=2)
- delta = now - past
- hours_ago = delta.total_seconds() / 3600
- assert abs(hours_ago - 2) < 0.01
-
-
-# --- Validation error response patterns ---
-
-
-class TestValidationErrorResponse:
- """Tests for validation error response patterns."""
-
- def _validation_error(self, field, message):
- return {
- "success": False,
- "error": f"Validation error: {message}",
- "error_code": "VALIDATION_ERROR",
- "details": {"field": field, "message": message},
- }
-
- def test_includes_field(self):
- response = self._validation_error("name", "Required")
- assert response["details"]["field"] == "name"
-
- def test_includes_message(self):
- response = self._validation_error("email", "Invalid format")
- assert response["details"]["message"] == "Invalid format"
-
- def test_has_validation_code(self):
- response = self._validation_error("f", "m")
- assert response["error_code"] == "VALIDATION_ERROR"
-
-
-# --- Feature disabled response patterns ---
-
-
-class TestFeatureDisabledResponse:
- """Tests for feature disabled response patterns."""
-
- def _feature_disabled(self, feature):
- return {
- "success": False,
- "error": f"{feature} is disabled",
- "error_code": "FEATURE_DISABLED",
- }
-
- def test_error_message_includes_feature(self):
- response = self._feature_disabled("News")
- assert "News" in response["error"]
-
- def test_has_feature_disabled_code(self):
- response = self._feature_disabled("News")
- assert response["error_code"] == "FEATURE_DISABLED"
-
-
-# --- Not found response patterns ---
-
-
-class TestNotFoundResponse:
- """Tests for not found response patterns."""
-
- def _not_found(self, resource_type, resource_id):
- return {
- "success": False,
- "error": f"{resource_type} not found: {resource_id}",
- "error_code": "NOT_FOUND",
- }
-
- def test_error_includes_type(self):
- response = self._not_found("Subscription", "123")
- assert "Subscription" in response["error"]
-
- def test_error_includes_id(self):
- response = self._not_found("Card", "card-456")
- assert "card-456" in response["error"]
-
- def test_has_not_found_code(self):
- response = self._not_found("User", "1")
- assert response["error_code"] == "NOT_FOUND"
-
-
-# --- Conflict response patterns ---
-
-
-class TestConflictResponse:
- """Tests for conflict response patterns."""
-
- def _conflict(self, resource, message):
- return {
- "success": False,
- "error": message,
- "error_code": "CONFLICT",
- "details": {"resource": resource},
- }
-
- def test_includes_resource(self):
- response = self._conflict("folder", "Already exists")
- assert response["details"]["resource"] == "folder"
-
- def test_has_conflict_code(self):
- response = self._conflict("subscription", "Duplicate")
- assert response["error_code"] == "CONFLICT"
diff --git a/tests/news/test_api_subscription_logic_behavior.py b/tests/news/test_api_subscription_logic_behavior.py
deleted file mode 100644
index 299ff4ec0c..0000000000
--- a/tests/news/test_api_subscription_logic_behavior.py
+++ /dev/null
@@ -1,550 +0,0 @@
-"""
-Deep behavioral tests for api.py subscription management logic patterns.
-Tests update_subscription field mapping, create_subscription defaults,
-subscription dict format, and news feed construction patterns.
-"""
-
-from datetime import datetime, timezone, timedelta
-
-
-# --- update_subscription field mapping ---
-
-
-class TestUpdateSubscriptionFieldMapping:
- """Tests for the field-by-field update pattern in update_subscription."""
-
- def _apply_updates(self, existing, data):
- """Mirror the field update pattern from api.py update_subscription."""
- if "name" in data:
- existing["name"] = data["name"]
- if "query_or_topic" in data:
- existing["query_or_topic"] = data["query_or_topic"]
- if "subscription_type" in data:
- existing["subscription_type"] = data["subscription_type"]
- if "refresh_interval_minutes" in data:
- old_interval = existing.get("refresh_interval_minutes")
- existing["refresh_interval_minutes"] = data[
- "refresh_interval_minutes"
- ]
- if old_interval != existing["refresh_interval_minutes"]:
- existing["next_refresh_recalculated"] = True
- if "is_active" in data:
- existing["status"] = "active" if data["is_active"] else "paused"
- if "status" in data:
- existing["status"] = data["status"]
- if "folder_id" in data:
- existing["folder_id"] = data["folder_id"]
- if "model_provider" in data:
- existing["model_provider"] = data["model_provider"]
- if "model" in data:
- existing["model"] = data["model"]
- if "search_strategy" in data:
- existing["search_strategy"] = data["search_strategy"]
- if "custom_endpoint" in data:
- existing["custom_endpoint"] = data["custom_endpoint"]
- if "search_engine" in data:
- existing["search_engine"] = data["search_engine"]
- if "search_iterations" in data:
- existing["search_iterations"] = data["search_iterations"]
- if "questions_per_iteration" in data:
- existing["questions_per_iteration"] = data[
- "questions_per_iteration"
- ]
- return existing
-
- def test_update_name(self):
- existing = {"name": "old"}
- result = self._apply_updates(existing, {"name": "new"})
- assert result["name"] == "new"
-
- def test_update_query(self):
- existing = {"query_or_topic": "old query"}
- result = self._apply_updates(existing, {"query_or_topic": "new query"})
- assert result["query_or_topic"] == "new query"
-
- def test_update_is_active_true(self):
- existing = {"status": "paused"}
- result = self._apply_updates(existing, {"is_active": True})
- assert result["status"] == "active"
-
- def test_update_is_active_false(self):
- existing = {"status": "active"}
- result = self._apply_updates(existing, {"is_active": False})
- assert result["status"] == "paused"
-
- def test_update_status_directly(self):
- existing = {"status": "active"}
- result = self._apply_updates(existing, {"status": "expired"})
- assert result["status"] == "expired"
-
- def test_update_interval_recalculates(self):
- existing = {"refresh_interval_minutes": 60}
- result = self._apply_updates(
- existing, {"refresh_interval_minutes": 120}
- )
- assert result["refresh_interval_minutes"] == 120
- assert result.get("next_refresh_recalculated") is True
-
- def test_same_interval_no_recalculate(self):
- existing = {"refresh_interval_minutes": 60}
- result = self._apply_updates(existing, {"refresh_interval_minutes": 60})
- assert result.get("next_refresh_recalculated") is None
-
- def test_update_model_provider(self):
- existing = {"model_provider": "OLLAMA"}
- result = self._apply_updates(existing, {"model_provider": "openai"})
- assert result["model_provider"] == "openai"
-
- def test_update_model(self):
- existing = {"model": "llama3"}
- result = self._apply_updates(existing, {"model": "gpt-4"})
- assert result["model"] == "gpt-4"
-
- def test_update_search_engine(self):
- existing = {"search_engine": None}
- result = self._apply_updates(existing, {"search_engine": "google"})
- assert result["search_engine"] == "google"
-
- def test_update_search_iterations(self):
- existing = {"search_iterations": 3}
- result = self._apply_updates(existing, {"search_iterations": 5})
- assert result["search_iterations"] == 5
-
- def test_update_questions_per_iteration(self):
- existing = {"questions_per_iteration": 5}
- result = self._apply_updates(existing, {"questions_per_iteration": 10})
- assert result["questions_per_iteration"] == 10
-
- def test_update_folder_id(self):
- existing = {"folder_id": None}
- result = self._apply_updates(existing, {"folder_id": "folder-123"})
- assert result["folder_id"] == "folder-123"
-
- def test_update_custom_endpoint(self):
- existing = {"custom_endpoint": None}
- result = self._apply_updates(
- existing, {"custom_endpoint": "http://api.example.com"}
- )
- assert result["custom_endpoint"] == "http://api.example.com"
-
- def test_partial_update_preserves_other_fields(self):
- existing = {
- "name": "original",
- "query_or_topic": "test",
- "status": "active",
- }
- result = self._apply_updates(existing, {"name": "updated"})
- assert result["name"] == "updated"
- assert result["query_or_topic"] == "test"
- assert result["status"] == "active"
-
- def test_empty_update_changes_nothing(self):
- existing = {"name": "test", "status": "active"}
- result = self._apply_updates(existing, {})
- assert result == {"name": "test", "status": "active"}
-
-
-# --- Subscription API format ---
-
-
-class TestSubscriptionAPIFormat:
- """Tests for subscription dict formatting in get_subscription."""
-
- def _format_subscription(self, sub):
- """Mirror the subscription formatting from api.py get_subscription."""
- return {
- "id": sub["id"],
- "name": sub.get("name") or "",
- "query_or_topic": sub["query_or_topic"],
- "subscription_type": sub["subscription_type"],
- "refresh_interval_minutes": sub["refresh_interval_minutes"],
- "is_active": sub.get("status") == "active",
- "status": sub.get("status"),
- "folder_id": sub.get("folder_id"),
- "model_provider": sub.get("model_provider"),
- "model": sub.get("model"),
- "search_strategy": sub.get("search_strategy"),
- "custom_endpoint": sub.get("custom_endpoint"),
- "search_engine": sub.get("search_engine"),
- "search_iterations": sub.get("search_iterations") or 3,
- "questions_per_iteration": sub.get("questions_per_iteration") or 5,
- "created_at": sub.get("created_at"),
- "updated_at": sub.get("updated_at"),
- }
-
- def test_is_active_from_status(self):
- sub = {
- "id": "1",
- "query_or_topic": "q",
- "subscription_type": "search",
- "refresh_interval_minutes": 60,
- "status": "active",
- }
- result = self._format_subscription(sub)
- assert result["is_active"] is True
-
- def test_inactive_from_paused(self):
- sub = {
- "id": "1",
- "query_or_topic": "q",
- "subscription_type": "search",
- "refresh_interval_minutes": 60,
- "status": "paused",
- }
- result = self._format_subscription(sub)
- assert result["is_active"] is False
-
- def test_name_fallback_empty(self):
- sub = {
- "id": "1",
- "query_or_topic": "q",
- "subscription_type": "search",
- "refresh_interval_minutes": 60,
- "name": None,
- }
- result = self._format_subscription(sub)
- assert result["name"] == ""
-
- def test_search_iterations_default_3(self):
- sub = {
- "id": "1",
- "query_or_topic": "q",
- "subscription_type": "search",
- "refresh_interval_minutes": 60,
- "search_iterations": None,
- }
- result = self._format_subscription(sub)
- assert result["search_iterations"] == 3
-
- def test_questions_per_iteration_default_5(self):
- sub = {
- "id": "1",
- "query_or_topic": "q",
- "subscription_type": "search",
- "refresh_interval_minutes": 60,
- "questions_per_iteration": None,
- }
- result = self._format_subscription(sub)
- assert result["questions_per_iteration"] == 5
-
-
-# --- get_subscriptions list format ---
-
-
-class TestGetSubscriptionsListFormat:
- """Tests for the subscription list format from get_subscriptions."""
-
- def _format_sub_list_item(self, sub, total_runs=0):
- """Mirror the subscription list formatting."""
- return {
- "id": sub["id"],
- "query": sub["query_or_topic"],
- "type": sub.get("subscription_type"),
- "refresh_minutes": sub.get("refresh_interval_minutes"),
- "created_at": sub.get("created_at"),
- "next_refresh": sub.get("next_refresh"),
- "last_refreshed": sub.get("last_refresh"),
- "is_active": sub.get("status") == "active",
- "total_runs": total_runs,
- "name": sub.get("name") or "",
- "folder_id": sub.get("folder_id"),
- }
-
- def test_query_maps_from_query_or_topic(self):
- sub = {"id": "1", "query_or_topic": "AI news", "status": "active"}
- result = self._format_sub_list_item(sub)
- assert result["query"] == "AI news"
-
- def test_total_runs_included(self):
- sub = {"id": "1", "query_or_topic": "test", "status": "active"}
- result = self._format_sub_list_item(sub, total_runs=42)
- assert result["total_runs"] == 42
-
- def test_is_active_true(self):
- sub = {"id": "1", "query_or_topic": "test", "status": "active"}
- result = self._format_sub_list_item(sub)
- assert result["is_active"] is True
-
- def test_like_pattern_for_subscription_id(self):
- """Test the LIKE pattern used to count research runs."""
- sub_id = "sub-abc-123"
- like_pattern = f'%"subscription_id": "{sub_id}"%'
- assert f'"subscription_id": "{sub_id}"' in like_pattern
- assert like_pattern.startswith("%")
- assert like_pattern.endswith("%")
-
-
-# --- News feed item construction ---
-
-
-class TestNewsFeedItemConstruction:
- """Tests for news_item dict construction in get_news_feed."""
-
- def _build_news_item(
- self,
- row,
- metadata,
- headline,
- summary,
- findings,
- category,
- topics,
- links,
- ):
- research_id = row.get("uuid_id") or str(row["id"])
- return {
- "id": f"news-{research_id}",
- "headline": headline,
- "category": category,
- "summary": summary or f"Research analysis for: {headline[:100]}",
- "findings": findings,
- "impact_score": metadata.get("impact_score", 0),
- "upvotes": metadata.get("upvotes", 0),
- "downvotes": metadata.get("downvotes", 0),
- "source_url": f"/results/{research_id}",
- "topics": topics,
- "links": links,
- "research_id": research_id,
- "original_query": row["query"],
- "is_news": metadata.get("is_news_search", False),
- "news_date": metadata.get("news_date"),
- "news_source": metadata.get("news_source"),
- "priority": metadata.get("priority", "normal"),
- }
-
- def test_id_has_news_prefix(self):
- row = {"id": "123", "uuid_id": "abc-123", "query": "test"}
- item = self._build_news_item(
- row, {}, "Headline", "", "", "Tech", [], []
- )
- assert item["id"] == "news-abc-123"
-
- def test_uses_uuid_id_when_available(self):
- row = {"id": 1, "uuid_id": "uuid-val", "query": "test"}
- item = self._build_news_item(row, {}, "H", "", "", "C", [], [])
- assert item["research_id"] == "uuid-val"
-
- def test_falls_back_to_str_id(self):
- row = {"id": 42, "uuid_id": None, "query": "test"}
- item = self._build_news_item(row, {}, "H", "", "", "C", [], [])
- assert item["research_id"] == "42"
-
- def test_impact_score_default_zero(self):
- row = {"id": "1", "uuid_id": "1", "query": "test"}
- item = self._build_news_item(row, {}, "H", "", "", "C", [], [])
- assert item["impact_score"] == 0
-
- def test_priority_default_normal(self):
- row = {"id": "1", "uuid_id": "1", "query": "test"}
- item = self._build_news_item(row, {}, "H", "", "", "C", [], [])
- assert item["priority"] == "normal"
-
- def test_summary_fallback(self):
- row = {"id": "1", "uuid_id": "1", "query": "test"}
- item = self._build_news_item(
- row, {}, "My Headline", "", "", "C", [], []
- )
- assert "Research analysis for: My Headline" in item["summary"]
-
- def test_source_url_format(self):
- row = {"id": "1", "uuid_id": "res-abc", "query": "test"}
- item = self._build_news_item(row, {}, "H", "", "", "C", [], [])
- assert item["source_url"] == "/results/res-abc"
-
- def test_is_news_flag(self):
- row = {"id": "1", "uuid_id": "1", "query": "test"}
- item = self._build_news_item(
- row, {"is_news_search": True}, "H", "", "", "C", [], []
- )
- assert item["is_news"] is True
-
- def test_is_news_default_false(self):
- row = {"id": "1", "uuid_id": "1", "query": "test"}
- item = self._build_news_item(row, {}, "H", "", "", "C", [], [])
- assert item["is_news"] is False
-
- def test_preserves_original_query(self):
- row = {"id": "1", "uuid_id": "1", "query": "original query text"}
- item = self._build_news_item(row, {}, "H", "", "", "C", [], [])
- assert item["original_query"] == "original query text"
-
-
-# --- Headline determination logic ---
-
-
-class TestHeadlineDetermination:
- """Tests for the headline determination logic in get_news_feed."""
-
- def _determine_headline(self, row_title, metadata, row_query):
- """Mirror headline determination from get_news_feed."""
- headline = row_title or metadata.get("generated_headline")
- if not headline and metadata.get("is_news_search"):
- subscription_name = metadata.get("subscription_name")
- if subscription_name:
- headline = f"News Update: {subscription_name}"
- else:
- headline = f"News: {row_query[:60]}..."
- return headline
-
- def test_uses_row_title_first(self):
- result = self._determine_headline(
- "Row Title", {"generated_headline": "Meta"}, "query"
- )
- assert result == "Row Title"
-
- def test_uses_metadata_headline_second(self):
- result = self._determine_headline(
- None, {"generated_headline": "Meta Headline"}, "query"
- )
- assert result == "Meta Headline"
-
- def test_news_search_uses_subscription_name(self):
- result = self._determine_headline(
- None,
- {"is_news_search": True, "subscription_name": "My Sub"},
- "query",
- )
- assert result == "News Update: My Sub"
-
- def test_news_search_fallback_to_query(self):
- result = self._determine_headline(
- None,
- {"is_news_search": True},
- "AI breakthroughs today",
- )
- assert result.startswith("News: AI")
-
- def test_no_headline_returns_none(self):
- result = self._determine_headline(None, {}, "query")
- assert result is None
-
- def test_skip_no_headline(self):
- headline = None
- skip = not headline or headline == "[No headline available]"
- assert skip is True
-
- def test_skip_placeholder_headline(self):
- headline = "[No headline available]"
- skip = not headline or headline == "[No headline available]"
- assert skip is True
-
- def test_dont_skip_valid_headline(self):
- headline = "Breaking News"
- skip = not headline or headline == "[No headline available]"
- assert skip is False
-
-
-# --- Category and topics defaults ---
-
-
-class TestCategoryAndTopicsDefaults:
- """Tests for category/topics default patterns."""
-
- def test_category_from_metadata(self):
- metadata = {"category": "Technology"}
- category = metadata.get("category")
- if not category:
- category = "[Uncategorized]"
- assert category == "Technology"
-
- def test_category_default_uncategorized(self):
- metadata = {}
- category = metadata.get("category")
- if not category:
- category = "[Uncategorized]"
- assert category == "[Uncategorized]"
-
- def test_topics_from_metadata(self):
- metadata = {"generated_topics": ["AI", "ML"]}
- topics = metadata.get("generated_topics")
- if not topics:
- topics = ["[No topics]"]
- assert topics == ["AI", "ML"]
-
- def test_topics_default_placeholder(self):
- metadata = {}
- topics = metadata.get("generated_topics")
- if not topics:
- topics = ["[No topics]"]
- assert topics == ["[No topics]"]
-
-
-# --- Status filtering ---
-
-
-class TestStatusFiltering:
- """Tests for status-based filtering in news feed."""
-
- def test_skip_in_progress(self):
- status = "in_progress"
- skip = status in ["in_progress", "suspended"]
- assert skip is True
-
- def test_skip_suspended(self):
- status = "suspended"
- skip = status in ["in_progress", "suspended"]
- assert skip is True
-
- def test_dont_skip_completed(self):
- status = "completed"
- skip = status in ["in_progress", "suspended"]
- assert skip is False
-
- def test_dont_skip_failed(self):
- status = "failed"
- skip = status in ["in_progress", "suspended"]
- assert skip is False
-
-
-# --- Limit validation ---
-
-
-class TestLimitValidation:
- """Tests for limit validation in get_news_feed."""
-
- def test_limit_zero_invalid(self):
- limit = 0
- assert limit < 1
-
- def test_limit_negative_invalid(self):
- limit = -5
- assert limit < 1
-
- def test_limit_one_valid(self):
- limit = 1
- assert limit >= 1
-
- def test_limit_large_valid(self):
- limit = 10000
- assert limit >= 1
-
-
-# --- Next refresh calculation ---
-
-
-class TestNextRefreshRecalculation:
- """Tests for next_refresh recalculation on interval change."""
-
- def test_new_interval_calculates_from_now(self):
- now = datetime.now(timezone.utc)
- new_minutes = 120
- next_refresh = now + timedelta(minutes=new_minutes)
- assert next_refresh > now
-
- def test_old_interval_differs_triggers_recalc(self):
- old = 60
- new = 120
- should_recalc = old != new
- assert should_recalc is True
-
- def test_same_interval_no_recalc(self):
- old = 60
- new = 60
- should_recalc = old != new
- assert should_recalc is False
-
- def test_recalc_from_last_refresh(self):
- last_refresh = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- new_minutes = 30
- next_refresh = last_refresh + timedelta(minutes=new_minutes)
- assert next_refresh.minute == 30
diff --git a/tests/news/test_async_patterns_behavior.py b/tests/news/test_async_patterns_behavior.py
deleted file mode 100644
index 50c360b811..0000000000
--- a/tests/news/test_async_patterns_behavior.py
+++ /dev/null
@@ -1,583 +0,0 @@
-"""
-Deep behavioral tests for async operation patterns.
-Tests queue management, task scheduling, promise patterns,
-and concurrent operation logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-from collections import deque
-
-
-# --- Queue management patterns ---
-
-
-class TestQueueManagement:
- """Tests for queue management patterns."""
-
- def _create_queue(self, max_size=None):
- """Create a queue."""
- return {
- "items": deque(maxlen=max_size),
- "max_size": max_size,
- }
-
- def _enqueue(self, queue, item):
- """Add item to queue."""
- if queue["max_size"] and len(queue["items"]) >= queue["max_size"]:
- return False
- queue["items"].append(item)
- return True
-
- def _dequeue(self, queue):
- """Remove and return item from queue."""
- if not queue["items"]:
- return None
- return queue["items"].popleft()
-
- def _peek(self, queue):
- """View next item without removing."""
- if not queue["items"]:
- return None
- return queue["items"][0]
-
- def _is_empty(self, queue):
- """Check if queue is empty."""
- return len(queue["items"]) == 0
-
- def test_enqueue_adds_item(self):
- queue = self._create_queue()
- self._enqueue(queue, "item1")
- assert len(queue["items"]) == 1
-
- def test_dequeue_removes_item(self):
- queue = self._create_queue()
- self._enqueue(queue, "item1")
- result = self._dequeue(queue)
- assert result == "item1"
- assert self._is_empty(queue)
-
- def test_fifo_order(self):
- queue = self._create_queue()
- self._enqueue(queue, "first")
- self._enqueue(queue, "second")
- assert self._dequeue(queue) == "first"
- assert self._dequeue(queue) == "second"
-
- def test_max_size_enforced(self):
- queue = self._create_queue(max_size=2)
- self._enqueue(queue, "1")
- self._enqueue(queue, "2")
- result = self._enqueue(queue, "3")
- assert result is False
-
- def test_peek_doesnt_remove(self):
- queue = self._create_queue()
- self._enqueue(queue, "item")
- peeked = self._peek(queue)
- assert peeked == "item"
- assert not self._is_empty(queue)
-
-
-class TestPriorityQueue:
- """Tests for priority queue patterns."""
-
- def _create_priority_queue(self):
- """Create a priority queue."""
- return {"items": []}
-
- def _enqueue_priority(self, pq, item, priority):
- """Add item with priority (lower = higher priority)."""
- entry = {"item": item, "priority": priority}
- pq["items"].append(entry)
- pq["items"].sort(key=lambda x: x["priority"])
-
- def _dequeue_priority(self, pq):
- """Remove and return highest priority item."""
- if not pq["items"]:
- return None
- return pq["items"].pop(0)["item"]
-
- def test_priority_order(self):
- pq = self._create_priority_queue()
- self._enqueue_priority(pq, "low", 10)
- self._enqueue_priority(pq, "high", 1)
- self._enqueue_priority(pq, "medium", 5)
- assert self._dequeue_priority(pq) == "high"
- assert self._dequeue_priority(pq) == "medium"
- assert self._dequeue_priority(pq) == "low"
-
-
-# --- Task scheduling patterns ---
-
-
-class TestTaskScheduling:
- """Tests for task scheduling patterns."""
-
- def _create_task(self, task_id, execute_at=None, priority=0):
- """Create a scheduled task."""
- return {
- "id": task_id,
- "execute_at": execute_at or datetime.now(timezone.utc),
- "priority": priority,
- "status": "pending",
- "created_at": datetime.now(timezone.utc),
- }
-
- def _is_due(self, task):
- """Check if task is due for execution."""
- return task["execute_at"] <= datetime.now(timezone.utc)
-
- def _get_due_tasks(self, tasks):
- """Get all tasks that are due."""
- return [
- t for t in tasks if self._is_due(t) and t["status"] == "pending"
- ]
-
- def _schedule_task(self, tasks, task_id, delay_seconds):
- """Schedule a new task with delay."""
- execute_at = datetime.now(timezone.utc) + timedelta(
- seconds=delay_seconds
- )
- task = self._create_task(task_id, execute_at)
- tasks.append(task)
- return task
-
- def test_task_creation(self):
- task = self._create_task("task-1")
- assert task["id"] == "task-1"
- assert task["status"] == "pending"
-
- def test_is_due_immediate(self):
- task = self._create_task("task-1")
- assert self._is_due(task) is True
-
- def test_is_due_future(self):
- future = datetime.now(timezone.utc) + timedelta(hours=1)
- task = self._create_task("task-1", execute_at=future)
- assert self._is_due(task) is False
-
- def test_get_due_tasks(self):
- now = datetime.now(timezone.utc)
- past = now - timedelta(hours=1)
- future = now + timedelta(hours=1)
- tasks = [
- self._create_task("1", execute_at=past),
- self._create_task("2", execute_at=future),
- self._create_task("3", execute_at=past),
- ]
- due = self._get_due_tasks(tasks)
- assert len(due) == 2
-
-
-class TestRecurringTasks:
- """Tests for recurring task patterns."""
-
- def _create_recurring_task(self, task_id, interval_seconds):
- """Create a recurring task."""
- return {
- "id": task_id,
- "interval_seconds": interval_seconds,
- "last_run": None,
- "next_run": datetime.now(timezone.utc),
- "run_count": 0,
- }
-
- def _calculate_next_run(self, task):
- """Calculate next run time."""
- return datetime.now(timezone.utc) + timedelta(
- seconds=task["interval_seconds"]
- )
-
- def _mark_executed(self, task):
- """Mark task as executed and schedule next run."""
- task["last_run"] = datetime.now(timezone.utc)
- task["next_run"] = self._calculate_next_run(task)
- task["run_count"] += 1
- return task
-
- def _is_overdue(self, task, threshold_seconds=60):
- """Check if task is significantly overdue."""
- if not task["next_run"]:
- return False
- overdue_by = (
- datetime.now(timezone.utc) - task["next_run"]
- ).total_seconds()
- return overdue_by > threshold_seconds
-
- def test_recurring_task_creation(self):
- task = self._create_recurring_task("task-1", interval_seconds=3600)
- assert task["interval_seconds"] == 3600
- assert task["run_count"] == 0
-
- def test_mark_executed_updates_count(self):
- task = self._create_recurring_task("task-1", interval_seconds=60)
- self._mark_executed(task)
- assert task["run_count"] == 1
- assert task["last_run"] is not None
-
-
-# --- Job status patterns ---
-
-
-class TestJobStatus:
- """Tests for job status management patterns."""
-
- def _create_job(self, job_id):
- """Create a job."""
- return {
- "id": job_id,
- "status": "pending",
- "progress": 0,
- "result": None,
- "error": None,
- "started_at": None,
- "completed_at": None,
- }
-
- def _start_job(self, job):
- """Start a job."""
- job["status"] = "running"
- job["started_at"] = datetime.now(timezone.utc)
- return job
-
- def _complete_job(self, job, result):
- """Complete a job successfully."""
- job["status"] = "completed"
- job["result"] = result
- job["progress"] = 100
- job["completed_at"] = datetime.now(timezone.utc)
- return job
-
- def _fail_job(self, job, error):
- """Fail a job."""
- job["status"] = "failed"
- job["error"] = error
- job["completed_at"] = datetime.now(timezone.utc)
- return job
-
- def _update_progress(self, job, progress):
- """Update job progress."""
- job["progress"] = min(100, max(0, progress))
- return job
-
- def test_job_starts_pending(self):
- job = self._create_job("job-1")
- assert job["status"] == "pending"
-
- def test_start_job(self):
- job = self._create_job("job-1")
- self._start_job(job)
- assert job["status"] == "running"
- assert job["started_at"] is not None
-
- def test_complete_job(self):
- job = self._create_job("job-1")
- self._start_job(job)
- self._complete_job(job, {"data": "result"})
- assert job["status"] == "completed"
- assert job["result"] == {"data": "result"}
-
- def test_fail_job(self):
- job = self._create_job("job-1")
- self._start_job(job)
- self._fail_job(job, "Something went wrong")
- assert job["status"] == "failed"
- assert job["error"] == "Something went wrong"
-
-
-# --- Promise/Future patterns ---
-
-
-class TestPromisePatterns:
- """Tests for promise/future patterns."""
-
- def _create_promise(self):
- """Create a promise."""
- return {
- "state": "pending",
- "value": None,
- "error": None,
- "callbacks": [],
- }
-
- def _resolve(self, promise, value):
- """Resolve promise with value."""
- if promise["state"] != "pending":
- return False
- promise["state"] = "fulfilled"
- promise["value"] = value
- return True
-
- def _reject(self, promise, error):
- """Reject promise with error."""
- if promise["state"] != "pending":
- return False
- promise["state"] = "rejected"
- promise["error"] = error
- return True
-
- def _is_settled(self, promise):
- """Check if promise is settled."""
- return promise["state"] != "pending"
-
- def test_promise_starts_pending(self):
- promise = self._create_promise()
- assert promise["state"] == "pending"
-
- def test_resolve_promise(self):
- promise = self._create_promise()
- self._resolve(promise, "result")
- assert promise["state"] == "fulfilled"
- assert promise["value"] == "result"
-
- def test_reject_promise(self):
- promise = self._create_promise()
- self._reject(promise, "error")
- assert promise["state"] == "rejected"
- assert promise["error"] == "error"
-
- def test_cannot_resolve_twice(self):
- promise = self._create_promise()
- self._resolve(promise, "first")
- result = self._resolve(promise, "second")
- assert result is False
- assert promise["value"] == "first"
-
-
-# --- Batch processing patterns ---
-
-
-class TestBatchProcessing:
- """Tests for batch processing patterns."""
-
- def _create_batch(self, items, batch_size):
- """Split items into batches."""
- return [
- items[i : i + batch_size] for i in range(0, len(items), batch_size)
- ]
-
- def _process_batch(self, batch, processor):
- """Process a batch of items."""
- results = []
- errors = []
- for item in batch:
- try:
- result = processor(item)
- results.append({"item": item, "result": result})
- except Exception as e:
- errors.append({"item": item, "error": str(e)})
- return {"results": results, "errors": errors}
-
- def _get_batch_stats(self, batches_results):
- """Get statistics from batch processing."""
- total_success = sum(len(br["results"]) for br in batches_results)
- total_errors = sum(len(br["errors"]) for br in batches_results)
- return {"success": total_success, "errors": total_errors}
-
- def test_create_batches(self):
- items = list(range(10))
- batches = self._create_batch(items, 3)
- assert len(batches) == 4
- assert batches[0] == [0, 1, 2]
-
- def test_process_batch_success(self):
- batch = [1, 2, 3]
- result = self._process_batch(batch, lambda x: x * 2)
- assert len(result["results"]) == 3
- assert len(result["errors"]) == 0
-
- def test_process_batch_with_errors(self):
- batch = [1, 0, 2]
-
- def processor(x):
- return 10 / x
-
- result = self._process_batch(batch, processor)
- assert len(result["errors"]) == 1
-
-
-# --- Retry patterns ---
-
-
-class TestRetryPatterns:
- """Tests for retry patterns."""
-
- def _should_retry(self, attempt, max_attempts, error_type=None):
- """Determine if should retry."""
- if attempt >= max_attempts:
- return False
- retryable_errors = ["timeout", "connection", "temporary"]
- if error_type and error_type not in retryable_errors:
- return False
- return True
-
- def _calculate_delay(self, attempt, base_delay=1.0, strategy="exponential"):
- """Calculate retry delay."""
- if strategy == "constant":
- return base_delay
- if strategy == "linear":
- return base_delay * (attempt + 1)
- if strategy == "exponential":
- return base_delay * (2**attempt)
- return base_delay
-
- def _create_retry_context(self, max_attempts=3, base_delay=1.0):
- """Create retry context."""
- return {
- "max_attempts": max_attempts,
- "base_delay": base_delay,
- "current_attempt": 0,
- "errors": [],
- }
-
- def test_should_retry_within_limit(self):
- assert self._should_retry(0, 3) is True
- assert self._should_retry(2, 3) is True
-
- def test_should_not_retry_at_limit(self):
- assert self._should_retry(3, 3) is False
-
- def test_exponential_delay(self):
- assert self._calculate_delay(0, 1.0) == 1.0
- assert self._calculate_delay(1, 1.0) == 2.0
- assert self._calculate_delay(2, 1.0) == 4.0
-
- def test_linear_delay(self):
- assert self._calculate_delay(0, 1.0, "linear") == 1.0
- assert self._calculate_delay(1, 1.0, "linear") == 2.0
-
-
-# --- Concurrency control patterns ---
-
-
-class TestConcurrencyControl:
- """Tests for concurrency control patterns."""
-
- def _create_semaphore(self, max_concurrent):
- """Create a semaphore."""
- return {
- "max_concurrent": max_concurrent,
- "current": 0,
- }
-
- def _acquire(self, semaphore):
- """Acquire semaphore slot."""
- if semaphore["current"] >= semaphore["max_concurrent"]:
- return False
- semaphore["current"] += 1
- return True
-
- def _release(self, semaphore):
- """Release semaphore slot."""
- if semaphore["current"] > 0:
- semaphore["current"] -= 1
- return True
- return False
-
- def _get_available(self, semaphore):
- """Get available slots."""
- return semaphore["max_concurrent"] - semaphore["current"]
-
- def test_acquire_within_limit(self):
- sem = self._create_semaphore(3)
- assert self._acquire(sem) is True
- assert sem["current"] == 1
-
- def test_acquire_at_limit(self):
- sem = self._create_semaphore(1)
- self._acquire(sem)
- assert self._acquire(sem) is False
-
- def test_release_allows_acquire(self):
- sem = self._create_semaphore(1)
- self._acquire(sem)
- self._release(sem)
- assert self._acquire(sem) is True
-
- def test_available_slots(self):
- sem = self._create_semaphore(5)
- self._acquire(sem)
- self._acquire(sem)
- assert self._get_available(sem) == 3
-
-
-# --- Timeout patterns ---
-
-
-class TestTimeoutPatterns:
- """Tests for timeout handling patterns."""
-
- def _create_timeout_context(self, timeout_seconds):
- """Create timeout context."""
- return {
- "timeout_seconds": timeout_seconds,
- "started_at": datetime.now(timezone.utc),
- "timed_out": False,
- }
-
- def _is_timed_out(self, context):
- """Check if operation has timed out."""
- elapsed = (
- datetime.now(timezone.utc) - context["started_at"]
- ).total_seconds()
- return elapsed > context["timeout_seconds"]
-
- def _get_remaining_time(self, context):
- """Get remaining time before timeout."""
- elapsed = (
- datetime.now(timezone.utc) - context["started_at"]
- ).total_seconds()
- remaining = context["timeout_seconds"] - elapsed
- return max(0, remaining)
-
- def test_not_timed_out_immediately(self):
- context = self._create_timeout_context(60)
- assert self._is_timed_out(context) is False
-
- def test_remaining_time(self):
- context = self._create_timeout_context(60)
- remaining = self._get_remaining_time(context)
- assert 59 < remaining <= 60
-
-
-# --- Work distribution patterns ---
-
-
-class TestWorkDistribution:
- """Tests for work distribution patterns."""
-
- def _round_robin(self, workers, task_index):
- """Distribute task using round robin."""
- return workers[task_index % len(workers)]
-
- def _least_loaded(self, workers_with_load):
- """Select worker with least load."""
- return min(workers_with_load, key=lambda w: w["load"])
-
- def _weighted_random(self, workers_with_weights):
- """Select worker by weight (simplified - returns highest weight)."""
- return max(workers_with_weights, key=lambda w: w["weight"])
-
- def test_round_robin(self):
- workers = ["w1", "w2", "w3"]
- assert self._round_robin(workers, 0) == "w1"
- assert self._round_robin(workers, 1) == "w2"
- assert self._round_robin(workers, 3) == "w1"
-
- def test_least_loaded(self):
- workers = [
- {"id": "w1", "load": 10},
- {"id": "w2", "load": 5},
- {"id": "w3", "load": 8},
- ]
- selected = self._least_loaded(workers)
- assert selected["id"] == "w2"
-
- def test_weighted(self):
- workers = [
- {"id": "w1", "weight": 1},
- {"id": "w2", "weight": 3},
- {"id": "w3", "weight": 2},
- ]
- selected = self._weighted_random(workers)
- assert selected["id"] == "w2"
diff --git a/tests/news/test_base_card_logic_behavior.py b/tests/news/test_base_card_logic_behavior.py
deleted file mode 100644
index fd3e816751..0000000000
--- a/tests/news/test_base_card_logic_behavior.py
+++ /dev/null
@@ -1,667 +0,0 @@
-"""
-Deep behavioral tests for base_card.py pure logic.
-Tests CardSource, CardVersion, BaseCard helper methods,
-impact calculation, topic extraction, and card type conversions.
-"""
-
-from datetime import datetime, timezone
-
-
-# --- CardSource structure ---
-
-
-class TestCardSourceStructure:
- """Tests for CardSource dataclass structure."""
-
- def _create_source(
- self, type, source_id=None, created_from="", metadata=None
- ):
- return {
- "type": type,
- "source_id": source_id,
- "created_from": created_from,
- "metadata": metadata or {},
- }
-
- def test_minimal_source(self):
- source = self._create_source("news_item")
- assert source["type"] == "news_item"
- assert source["source_id"] is None
-
- def test_full_source(self):
- source = self._create_source(
- type="user_search",
- source_id="search-123",
- created_from="User search",
- metadata={"query": "AI news"},
- )
- assert source["type"] == "user_search"
- assert source["source_id"] == "search-123"
- assert source["metadata"]["query"] == "AI news"
-
- def test_default_metadata_empty(self):
- source = self._create_source("subscription")
- assert source["metadata"] == {}
-
- def test_source_types(self):
- valid_types = [
- "news_item",
- "user_search",
- "subscription",
- "news_research",
- ]
- for t in valid_types:
- source = self._create_source(t)
- assert source["type"] == t
-
-
-# --- CardVersion structure ---
-
-
-class TestCardVersionStructure:
- """Tests for CardVersion fields."""
-
- def _create_version(
- self, version_id, created_at, content, query, strategy=None
- ):
- return {
- "version_id": version_id or "auto-generated-id",
- "created_at": created_at,
- "content": content,
- "query_used": query,
- "search_strategy": strategy,
- }
-
- def test_basic_version(self):
- version = self._create_version(
- version_id="v-123",
- created_at=datetime.now(timezone.utc),
- content={"result": "data"},
- query="test query",
- )
- assert version["version_id"] == "v-123"
- assert version["query_used"] == "test query"
-
- def test_auto_generate_version_id(self):
- version = self._create_version(
- version_id=None,
- created_at=datetime.now(timezone.utc),
- content={},
- query="q",
- )
- assert version["version_id"] == "auto-generated-id"
-
- def test_optional_strategy(self):
- version = self._create_version(
- version_id="v1",
- created_at=datetime.now(timezone.utc),
- content={},
- query="q",
- strategy="focused_iteration",
- )
- assert version["search_strategy"] == "focused_iteration"
-
-
-# --- Interaction structure ---
-
-
-class TestInteractionStructure:
- """Tests for card interaction dictionary."""
-
- def _get_default_interaction(self):
- return {
- "votes_up": 0,
- "votes_down": 0,
- "views": 0,
- "shares": 0,
- }
-
- def test_default_values(self):
- interaction = self._get_default_interaction()
- assert interaction["votes_up"] == 0
- assert interaction["votes_down"] == 0
- assert interaction["views"] == 0
- assert interaction["shares"] == 0
-
- def test_all_keys_present(self):
- interaction = self._get_default_interaction()
- expected_keys = {"votes_up", "votes_down", "views", "shares"}
- assert set(interaction.keys()) == expected_keys
-
-
-class TestInteractionUpdate:
- """Tests for updating interaction counts."""
-
- def test_increment_votes_up(self):
- interaction = {"votes_up": 5, "votes_down": 1}
- interaction["votes_up"] += 1
- assert interaction["votes_up"] == 6
-
- def test_increment_views(self):
- interaction = {"views": 100}
- interaction["views"] += 1
- assert interaction["views"] == 101
-
- def test_increment_shares(self):
- interaction = {"shares": 10}
- interaction["shares"] += 1
- assert interaction["shares"] == 11
-
-
-# --- Extract headline ---
-
-
-class TestExtractHeadline:
- """Tests for _extract_headline logic."""
-
- def _extract_headline(self, result):
- return (
- result.get("headline")
- or result.get("title")
- or result.get("query", "")[:100]
- )
-
- def test_from_headline(self):
- result = {"headline": "Breaking News"}
- assert self._extract_headline(result) == "Breaking News"
-
- def test_from_title_fallback(self):
- result = {"title": "News Title"}
- assert self._extract_headline(result) == "News Title"
-
- def test_from_query_fallback(self):
- result = {"query": "What is happening?"}
- assert self._extract_headline(result) == "What is happening?"
-
- def test_headline_takes_precedence(self):
- result = {
- "headline": "Primary",
- "title": "Secondary",
- "query": "Tertiary",
- }
- assert self._extract_headline(result) == "Primary"
-
- def test_empty_result(self):
- result = {}
- assert self._extract_headline(result) == ""
-
- def test_query_truncated_at_100(self):
- long_query = "A" * 200
- result = {"query": long_query}
- assert len(self._extract_headline(result)) == 100
-
-
-# --- Extract summary ---
-
-
-class TestExtractSummary:
- """Tests for _extract_summary logic."""
-
- def _extract_summary(self, result):
- return (
- result.get("summary")
- or result.get("current_knowledge")
- or result.get("formatted_findings", "")[:500]
- )
-
- def test_from_summary(self):
- result = {"summary": "Brief summary here"}
- assert self._extract_summary(result) == "Brief summary here"
-
- def test_from_current_knowledge(self):
- result = {"current_knowledge": "What we know so far"}
- assert self._extract_summary(result) == "What we know so far"
-
- def test_from_formatted_findings(self):
- result = {"formatted_findings": "Finding 1. Finding 2."}
- assert self._extract_summary(result) == "Finding 1. Finding 2."
-
- def test_summary_takes_precedence(self):
- result = {
- "summary": "Primary",
- "current_knowledge": "Secondary",
- "formatted_findings": "Tertiary",
- }
- assert self._extract_summary(result) == "Primary"
-
- def test_formatted_findings_truncated(self):
- long_findings = "B" * 600
- result = {"formatted_findings": long_findings}
- assert len(self._extract_summary(result)) == 500
-
-
-# --- Calculate impact ---
-
-
-class TestCalculateImpact:
- """Tests for _calculate_impact score logic."""
-
- def _calculate_impact(self, result):
- findings_count = len(result.get("findings", []))
- sources_count = len(result.get("sources", []))
- score = min(10, 5 + (findings_count // 5) + (sources_count // 3))
- return max(1, score)
-
- def test_no_findings_or_sources(self):
- result = {}
- assert self._calculate_impact(result) == 5
-
- def test_many_findings(self):
- result = {"findings": ["f"] * 15}
- # 5 + (15 // 5) = 5 + 3 = 8
- assert self._calculate_impact(result) == 8
-
- def test_many_sources(self):
- result = {"sources": ["s"] * 9}
- # 5 + 0 + (9 // 3) = 5 + 3 = 8
- assert self._calculate_impact(result) == 8
-
- def test_combined_high_score(self):
- result = {"findings": ["f"] * 20, "sources": ["s"] * 15}
- # 5 + (20 // 5) + (15 // 3) = 5 + 4 + 5 = 14, capped at 10
- assert self._calculate_impact(result) == 10
-
- def test_minimum_score_1(self):
- # Score formula always starts at 5, so min is 5
- result = {}
- assert self._calculate_impact(result) >= 1
-
- def test_maximum_score_10(self):
- result = {"findings": ["f"] * 100, "sources": ["s"] * 100}
- assert self._calculate_impact(result) == 10
-
-
-# --- Extract topics ---
-
-
-class TestExtractTopics:
- """Tests for _extract_topics logic."""
-
- def _extract_topics(self, result):
- topics = result.get("topics", [])
- if not topics and "query" in result:
- words = result["query"].lower().split()
- topics = [w for w in words if len(w) > 4][:5]
- return topics
-
- def test_from_topics_field(self):
- result = {"topics": ["AI", "Machine Learning", "Tech"]}
- assert self._extract_topics(result) == [
- "AI",
- "Machine Learning",
- "Tech",
- ]
-
- def test_from_query_when_no_topics(self):
- result = {"query": "artificial intelligence research developments"}
- topics = self._extract_topics(result)
- # Words > 4 chars: artificial, intelligence, research, developments
- assert "artificial" in topics
- assert "intelligence" in topics
-
- def test_max_5_topics_from_query(self):
- result = {
- "query": "a" * 5
- + " "
- + " ".join(["word" + str(i) for i in range(10)])
- }
- topics = self._extract_topics(result)
- assert len(topics) <= 5
-
- def test_filters_short_words(self):
- result = {"query": "the big and small new idea"}
- topics = self._extract_topics(result)
- # Only "small" is > 4 chars
- assert "the" not in topics
- assert "big" not in topics
- assert "and" not in topics
- assert "new" not in topics
- assert "idea" not in topics
- assert "small" in topics
-
- def test_empty_result(self):
- result = {}
- assert self._extract_topics(result) == []
-
-
-# --- Extract entities ---
-
-
-class TestExtractEntities:
- """Tests for _extract_entities logic."""
-
- def _extract_entities(self, result):
- return result.get(
- "entities", {"people": [], "places": [], "organizations": []}
- )
-
- def test_from_entities_field(self):
- result = {
- "entities": {
- "people": ["John Doe"],
- "places": ["New York"],
- "organizations": ["OpenAI"],
- }
- }
- entities = self._extract_entities(result)
- assert entities["people"] == ["John Doe"]
- assert entities["places"] == ["New York"]
- assert entities["organizations"] == ["OpenAI"]
-
- def test_default_empty_lists(self):
- result = {}
- entities = self._extract_entities(result)
- assert entities["people"] == []
- assert entities["places"] == []
- assert entities["organizations"] == []
-
-
-# --- Get latest version ---
-
-
-class TestGetLatestVersion:
- """Tests for get_latest_version logic."""
-
- def _get_latest_version(self, versions):
- if not versions:
- return None
- return max(versions, key=lambda v: v["created_at"])
-
- def test_no_versions(self):
- assert self._get_latest_version([]) is None
-
- def test_single_version(self):
- version = {"version_id": "v1", "created_at": datetime.now(timezone.utc)}
- result = self._get_latest_version([version])
- assert result["version_id"] == "v1"
-
- def test_multiple_versions(self):
- old = {
- "version_id": "v1",
- "created_at": datetime(2025, 1, 1, tzinfo=timezone.utc),
- }
- new = {
- "version_id": "v2",
- "created_at": datetime(2025, 6, 15, tzinfo=timezone.utc),
- }
- result = self._get_latest_version([old, new])
- assert result["version_id"] == "v2"
-
- def test_order_independent(self):
- new = {
- "version_id": "v2",
- "created_at": datetime(2025, 6, 15, tzinfo=timezone.utc),
- }
- old = {
- "version_id": "v1",
- "created_at": datetime(2025, 1, 1, tzinfo=timezone.utc),
- }
- result = self._get_latest_version([new, old])
- assert result["version_id"] == "v2"
-
-
-# --- To base dict ---
-
-
-class TestToBaseDict:
- """Tests for to_base_dict conversion."""
-
- def _to_base_dict(self, card):
- return {
- "id": card.get("id"),
- "topic": card.get("topic"),
- "user_id": card.get("user_id"),
- "created_at": card.get("created_at").isoformat()
- if card.get("created_at")
- else None,
- "updated_at": card.get("updated_at").isoformat()
- if card.get("updated_at")
- else None,
- "source": card.get("source"),
- "versions_count": len(card.get("versions", [])),
- "parent_card_id": card.get("parent_card_id"),
- "metadata": card.get("metadata", {}),
- "interaction": card.get("interaction", {}),
- "card_type": card.get("card_type"),
- }
-
- def test_includes_id(self):
- card = {"id": "card-123"}
- result = self._to_base_dict(card)
- assert result["id"] == "card-123"
-
- def test_includes_topic(self):
- card = {"topic": "AI News"}
- result = self._to_base_dict(card)
- assert result["topic"] == "AI News"
-
- def test_formats_created_at(self):
- dt = datetime(2025, 6, 15, 10, 0, 0, tzinfo=timezone.utc)
- card = {"created_at": dt}
- result = self._to_base_dict(card)
- assert "2025-06-15" in result["created_at"]
-
- def test_counts_versions(self):
- card = {"versions": [{"id": "v1"}, {"id": "v2"}]}
- result = self._to_base_dict(card)
- assert result["versions_count"] == 2
-
- def test_includes_interaction(self):
- card = {"interaction": {"votes_up": 10}}
- result = self._to_base_dict(card)
- assert result["interaction"]["votes_up"] == 10
-
-
-# --- Card types ---
-
-
-class TestCardTypes:
- """Tests for card type identifiers."""
-
- def test_news_card_type(self):
- assert "news" == "news"
-
- def test_research_card_type(self):
- assert "research" == "research"
-
- def test_update_card_type(self):
- assert "update" == "update"
-
- def test_overview_card_type(self):
- assert "overview" == "overview"
-
-
-# --- NewsCard specific fields ---
-
-
-class TestNewsCardFields:
- """Tests for NewsCard specific field defaults."""
-
- def _get_news_card_defaults(self):
- return {
- "headline": "",
- "summary": "",
- "category": "General",
- "impact_score": 5,
- "entities": {"people": [], "places": [], "organizations": []},
- "topics_extracted": [],
- "is_developing": False,
- "time_ago": "recent",
- "source_url": "",
- "analysis": "",
- "surprising_element": None,
- }
-
- def test_default_category(self):
- defaults = self._get_news_card_defaults()
- assert defaults["category"] == "General"
-
- def test_default_impact_score(self):
- defaults = self._get_news_card_defaults()
- assert defaults["impact_score"] == 5
-
- def test_default_is_developing(self):
- defaults = self._get_news_card_defaults()
- assert defaults["is_developing"] is False
-
- def test_default_time_ago(self):
- defaults = self._get_news_card_defaults()
- assert defaults["time_ago"] == "recent"
-
- def test_default_entities_structure(self):
- defaults = self._get_news_card_defaults()
- assert "people" in defaults["entities"]
- assert "places" in defaults["entities"]
- assert "organizations" in defaults["entities"]
-
-
-# --- ResearchCard specific fields ---
-
-
-class TestResearchCardFields:
- """Tests for ResearchCard specific field defaults."""
-
- def _get_research_card_defaults(self):
- return {
- "research_depth": "quick",
- "key_findings": [],
- "sources_count": 0,
- }
-
- def test_default_depth(self):
- defaults = self._get_research_card_defaults()
- assert defaults["research_depth"] == "quick"
-
- def test_valid_depths(self):
- valid_depths = ["quick", "detailed", "report"]
- for depth in valid_depths:
- assert depth in valid_depths
-
- def test_default_key_findings_empty(self):
- defaults = self._get_research_card_defaults()
- assert defaults["key_findings"] == []
-
-
-# --- UpdateCard specific fields ---
-
-
-class TestUpdateCardFields:
- """Tests for UpdateCard specific field defaults."""
-
- def _get_update_card_defaults(self):
- return {
- "update_type": "new_stories",
- "count": 0,
- "preview_items": [],
- }
-
- def test_default_update_type(self):
- defaults = self._get_update_card_defaults()
- assert defaults["update_type"] == "new_stories"
-
- def test_valid_update_types(self):
- valid_types = ["new_stories", "breaking", "follow_up"]
- for t in valid_types:
- assert t in valid_types
-
-
-# --- OverviewCard specific fields ---
-
-
-class TestOverviewCardFields:
- """Tests for OverviewCard specific field defaults."""
-
- def _get_overview_card_defaults(self):
- return {
- "topic": "News Overview",
- "stats": {
- "total_new": 0,
- "breaking": 0,
- "relevant": 0,
- "categories": {},
- },
- "summary": "",
- "top_stories": [],
- "trend_analysis": "",
- }
-
- def test_default_topic(self):
- defaults = self._get_overview_card_defaults()
- assert defaults["topic"] == "News Overview"
-
- def test_default_stats_structure(self):
- defaults = self._get_overview_card_defaults()
- assert "total_new" in defaults["stats"]
- assert "breaking" in defaults["stats"]
- assert "relevant" in defaults["stats"]
- assert "categories" in defaults["stats"]
-
-
-# --- Save card data ---
-
-
-class TestSaveCardData:
- """Tests for save() card_data structure."""
-
- def _build_save_data(self, card):
- return {
- "id": card.get("id"),
- "user_id": card.get("user_id"),
- "topic": card.get("topic"),
- "card_type": card.get("card_type"),
- "source_type": card.get("source", {}).get("type"),
- "source_id": card.get("source", {}).get("source_id"),
- "created_from": card.get("source", {}).get("created_from"),
- "parent_card_id": card.get("parent_card_id"),
- "metadata": card.get("metadata"),
- }
-
- def test_includes_source_fields(self):
- card = {
- "id": "c1",
- "source": {
- "type": "user_search",
- "source_id": "s1",
- "created_from": "Search",
- },
- }
- data = self._build_save_data(card)
- assert data["source_type"] == "user_search"
- assert data["source_id"] == "s1"
- assert data["created_from"] == "Search"
-
-
-# --- Add version data ---
-
-
-class TestAddVersionData:
- """Tests for add_version version_data structure."""
-
- def _build_version_data(self, research_results, query, strategy):
- return {
- "search_query": query,
- "research_result": research_results,
- "headline": research_results.get("headline", ""),
- "summary": research_results.get("summary", ""),
- "findings": research_results.get("findings", []),
- "sources": research_results.get("sources", []),
- "impact_score": 5, # Simplified
- "topics": research_results.get("topics", []),
- "entities": research_results.get("entities", {}),
- "strategy": strategy,
- }
-
- def test_includes_search_query(self):
- data = self._build_version_data(
- {"headline": "Test"}, "test query", "quick"
- )
- assert data["search_query"] == "test query"
-
- def test_includes_strategy(self):
- data = self._build_version_data({}, "q", "focused_iteration")
- assert data["strategy"] == "focused_iteration"
-
- def test_includes_full_research_result(self):
- result = {"headline": "News", "summary": "Details"}
- data = self._build_version_data(result, "q", "s")
- assert data["research_result"] == result
diff --git a/tests/news/test_card_storage_mapping_behavior.py b/tests/news/test_card_storage_mapping_behavior.py
deleted file mode 100644
index 7743a1785e..0000000000
--- a/tests/news/test_card_storage_mapping_behavior.py
+++ /dev/null
@@ -1,415 +0,0 @@
-"""
-Deep behavioral tests for card storage field mapping patterns.
-Tests _card_to_dict field mapping, source extraction, create field mapping,
-update field mapping, and get_by_user filtering.
-"""
-
-from datetime import datetime, timezone
-
-
-# --- _card_to_dict field mapping ---
-
-
-class TestCardToDictFieldMapping:
- """Tests for the _card_to_dict field mapping pattern from card_storage.py:226-279."""
-
- def _card_to_dict(self, card_attrs, extra_data=None):
- """Reproduce the mapping without requiring a real ORM object."""
- if extra_data is None:
- extra_data = {}
- return {
- "id": card_attrs.get("id"),
- "topic": card_attrs.get("title"), # title → topic
- "title": card_attrs.get("title"),
- "summary": card_attrs.get("summary"),
- "content": card_attrs.get("content"),
- "url": card_attrs.get("url"),
- "source_name": card_attrs.get("source_name"),
- "source_type": card_attrs.get("source_type"),
- "source_id": card_attrs.get("source_id"),
- "category": card_attrs.get("category"),
- "tags": card_attrs.get("tags"),
- "card_type": card_attrs.get("card_type"),
- "published_at": card_attrs["published_at"].isoformat()
- if card_attrs.get("published_at")
- else None,
- "discovered_at": card_attrs["discovered_at"].isoformat()
- if card_attrs.get("discovered_at")
- else None,
- "created_at": card_attrs["discovered_at"].isoformat()
- if card_attrs.get("discovered_at")
- else None,
- "updated_at": card_attrs["discovered_at"].isoformat()
- if card_attrs.get("discovered_at")
- else None,
- "is_read": card_attrs.get("is_read"),
- "read_at": card_attrs["read_at"].isoformat()
- if card_attrs.get("read_at")
- else None,
- "is_saved": card_attrs.get("is_saved"),
- "is_pinned": card_attrs.get("is_saved"), # Alias
- "saved_at": card_attrs["saved_at"].isoformat()
- if card_attrs.get("saved_at")
- else None,
- # Fields from extra_data
- "user_id": extra_data.get("user_id"),
- "parent_card_id": extra_data.get("parent_card_id"),
- "created_from": extra_data.get("created_from"),
- "is_archived": extra_data.get("is_archived", False),
- "metadata": extra_data.get("metadata", {}),
- "interaction": extra_data.get("interaction", {}),
- "source": {
- "type": card_attrs.get("source_type"),
- "source_id": card_attrs.get("source_id"),
- "created_from": extra_data.get("created_from", ""),
- "metadata": extra_data.get("metadata", {}),
- },
- }
-
- def test_title_mapped_to_topic(self):
- result = self._card_to_dict({"title": "AI News"})
- assert result["topic"] == "AI News"
-
- def test_title_preserved(self):
- result = self._card_to_dict({"title": "AI News"})
- assert result["title"] == "AI News"
-
- def test_is_saved_mapped_to_is_pinned(self):
- result = self._card_to_dict({"is_saved": True})
- assert result["is_pinned"] is True
-
- def test_is_saved_false_maps_pinned_false(self):
- result = self._card_to_dict({"is_saved": False})
- assert result["is_pinned"] is False
-
- def test_discovered_at_maps_to_created_at(self):
- dt = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- result = self._card_to_dict({"discovered_at": dt})
- assert result["created_at"] == dt.isoformat()
-
- def test_discovered_at_maps_to_updated_at(self):
- dt = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- result = self._card_to_dict({"discovered_at": dt})
- assert result["updated_at"] == dt.isoformat()
-
- def test_none_published_at(self):
- result = self._card_to_dict({"published_at": None})
- assert result["published_at"] is None
-
- def test_none_discovered_at(self):
- result = self._card_to_dict({"discovered_at": None})
- assert result["created_at"] is None
- assert result["updated_at"] is None
-
- def test_none_read_at(self):
- result = self._card_to_dict({"read_at": None})
- assert result["read_at"] is None
-
- def test_none_saved_at(self):
- result = self._card_to_dict({"saved_at": None})
- assert result["saved_at"] is None
-
- def test_extra_data_user_id(self):
- result = self._card_to_dict({}, extra_data={"user_id": "u1"})
- assert result["user_id"] == "u1"
-
- def test_extra_data_parent_card_id(self):
- result = self._card_to_dict({}, extra_data={"parent_card_id": "p1"})
- assert result["parent_card_id"] == "p1"
-
- def test_extra_data_created_from(self):
- result = self._card_to_dict({}, extra_data={"created_from": "Analysis"})
- assert result["created_from"] == "Analysis"
-
- def test_default_is_archived_false(self):
- result = self._card_to_dict({}, extra_data={})
- assert result["is_archived"] is False
-
- def test_is_archived_true(self):
- result = self._card_to_dict({}, extra_data={"is_archived": True})
- assert result["is_archived"] is True
-
- def test_default_metadata_empty(self):
- result = self._card_to_dict({}, extra_data={})
- assert result["metadata"] == {}
-
- def test_default_interaction_empty(self):
- result = self._card_to_dict({}, extra_data={})
- assert result["interaction"] == {}
-
- def test_source_dict_constructed(self):
- result = self._card_to_dict(
- {"source_type": "news_search", "source_id": "s1"},
- extra_data={"created_from": "Analysis", "metadata": {}},
- )
- assert result["source"]["type"] == "news_search"
- assert result["source"]["source_id"] == "s1"
- assert result["source"]["created_from"] == "Analysis"
-
-
-# --- Create field mapping ---
-
-
-class TestCreateFieldMapping:
- """Tests for the create method's field mapping from card_storage.py:42-98."""
-
- def _extract_source_info(self, data):
- """Reproduce source extraction from create()."""
- source_info = data.get("source", {})
- if isinstance(source_info, dict):
- source_type = source_info.get("type")
- source_id = source_info.get("source_id")
- created_from = source_info.get("created_from")
- else:
- source_type = data.get("source_type")
- source_id = data.get("source_id")
- created_from = data.get("created_from")
- return source_type, source_id, created_from
-
- def test_nested_source_dict(self):
- data = {
- "source": {
- "type": "news_search",
- "source_id": "s1",
- "created_from": "Analysis",
- }
- }
- source_type, source_id, created_from = self._extract_source_info(data)
- assert source_type == "news_search"
- assert source_id == "s1"
- assert created_from == "Analysis"
-
- def test_flat_source_fields(self):
- data = {
- "source": "not_a_dict",
- "source_type": "user_search",
- "source_id": "s2",
- "created_from": "Manual",
- }
- source_type, source_id, created_from = self._extract_source_info(data)
- assert source_type == "user_search"
- assert source_id == "s2"
- assert created_from == "Manual"
-
- def test_missing_source(self):
- data = {}
- source_type, source_id, created_from = self._extract_source_info(data)
- assert source_type is None
- assert source_id is None
- assert created_from is None
-
- def test_empty_source_dict(self):
- data = {"source": {}}
- source_type, source_id, created_from = self._extract_source_info(data)
- assert source_type is None
-
- def test_card_type_resolution(self):
- """card_type falls back to 'type' then 'news'."""
- assert {"card_type": "research"}.get(
- "card_type", {"type": "news"}.get("type", "news")
- ) == "research"
-
- def test_card_type_fallback_to_type(self):
- data = {"type": "update"}
- card_type = data.get("card_type", data.get("type", "news"))
- assert card_type == "update"
-
- def test_card_type_default_news(self):
- data = {}
- card_type = data.get("card_type", data.get("type", "news"))
- assert card_type == "news"
-
- def test_topic_mapped_to_title(self):
- data = {"topic": "My Topic"}
- title = data.get("topic", data.get("title", "Untitled"))
- assert title == "My Topic"
-
- def test_title_fallback(self):
- data = {"title": "My Title"}
- title = data.get("topic", data.get("title", "Untitled"))
- assert title == "My Title"
-
- def test_title_default_untitled(self):
- data = {}
- title = data.get("topic", data.get("title", "Untitled"))
- assert title == "Untitled"
-
- def test_url_from_source_url(self):
- data = {"source_url": "/results/123"}
- url = data.get("url", data.get("source_url"))
- assert url == "/results/123"
-
- def test_url_preferred_over_source_url(self):
- data = {"url": "https://example.com", "source_url": "/results/123"}
- url = data.get("url", data.get("source_url"))
- assert url == "https://example.com"
-
-
-# --- Update field mapping ---
-
-
-class TestUpdateFieldMapping:
- """Tests for the update method's field mapping from card_storage.py:108-141."""
-
- def test_is_pinned_maps_to_is_saved(self):
- data = {"is_pinned": True}
- is_saved = data.get("is_pinned")
- assert is_saved is True
-
- def test_pinned_false(self):
- data = {"is_pinned": False}
- is_saved = data.get("is_pinned")
- assert is_saved is False
-
- def test_last_viewed_sets_is_read(self):
- data = {"last_viewed": datetime.now(timezone.utc)}
- has_last_viewed = "last_viewed" in data
- assert has_last_viewed
-
- def test_is_archived_stored_in_extra_data(self):
- data = {"is_archived": True}
- extra_data = {}
- if "is_archived" in data:
- extra_data["is_archived"] = data["is_archived"]
- assert extra_data["is_archived"] is True
-
- def test_interaction_stored_in_extra_data(self):
- data = {"interaction": {"views": 5}}
- extra_data = {}
- if "interaction" in data:
- extra_data["interaction"] = data["interaction"]
- assert extra_data["interaction"]["views"] == 5
-
- def test_no_fields_no_changes(self):
- data = {}
- extra_data = {}
- if "is_archived" in data:
- extra_data["is_archived"] = data["is_archived"]
- if "interaction" in data:
- extra_data["interaction"] = data["interaction"]
- assert extra_data == {}
-
-
-# --- get_by_user filtering ---
-
-
-class TestGetByUserFiltering:
- """Tests for the get_by_user post-filtering from card_storage.py:281-302."""
-
- def _filter_by_user(self, all_cards, user_id, offset=0, limit=50):
- """Reproduce get_by_user filtering."""
- user_cards = [
- card
- for card in all_cards
- if card.get("user_id") == user_id
- and not card.get("is_archived", False)
- ]
- return user_cards[offset : offset + limit]
-
- def test_filters_by_user_id(self):
- cards = [
- {"user_id": "u1", "title": "A"},
- {"user_id": "u2", "title": "B"},
- {"user_id": "u1", "title": "C"},
- ]
- result = self._filter_by_user(cards, "u1")
- assert len(result) == 2
-
- def test_excludes_archived(self):
- cards = [
- {"user_id": "u1", "title": "A", "is_archived": False},
- {"user_id": "u1", "title": "B", "is_archived": True},
- ]
- result = self._filter_by_user(cards, "u1")
- assert len(result) == 1
- assert result[0]["title"] == "A"
-
- def test_default_is_archived_false(self):
- cards = [{"user_id": "u1", "title": "A"}]
- result = self._filter_by_user(cards, "u1")
- assert len(result) == 1
-
- def test_pagination_offset(self):
- cards = [{"user_id": "u1", "title": f"Card {i}"} for i in range(10)]
- result = self._filter_by_user(cards, "u1", offset=5)
- assert len(result) == 5
-
- def test_pagination_limit(self):
- cards = [{"user_id": "u1", "title": f"Card {i}"} for i in range(10)]
- result = self._filter_by_user(cards, "u1", limit=3)
- assert len(result) == 3
-
- def test_empty_cards(self):
- result = self._filter_by_user([], "u1")
- assert result == []
-
- def test_no_matching_user(self):
- cards = [{"user_id": "u2", "title": "A"}]
- result = self._filter_by_user(cards, "u1")
- assert result == []
-
-
-# --- get_latest_version logic ---
-
-
-class TestGetLatestVersionLogic:
- """Tests for get_latest_version from card_storage.py:304-327."""
-
- def _get_latest_version(self, card_data):
- """Reproduce get_latest_version logic."""
- if not card_data:
- return None
- extra_data = card_data.get("metadata", {})
- if "latest_version" in extra_data:
- return extra_data["latest_version"]
- card_id = card_data.get("id", "unknown")
- return {
- "version_id": f"{card_id}_v1",
- "version_number": 1,
- "headline": card_data.get("title"),
- "summary": card_data.get("summary"),
- "card_id": card_id,
- }
-
- def test_none_card_returns_none(self):
- assert self._get_latest_version(None) is None
-
- def test_with_latest_version(self):
- card = {
- "id": "c1",
- "metadata": {
- "latest_version": {"version_id": "v2", "headline": "Updated"}
- },
- }
- result = self._get_latest_version(card)
- assert result["version_id"] == "v2"
-
- def test_default_version_1(self):
- card = {"id": "c1", "title": "Test", "summary": "Sum", "metadata": {}}
- result = self._get_latest_version(card)
- assert result["version_number"] == 1
-
- def test_default_version_id_format(self):
- card = {"id": "card-123", "title": "Test", "metadata": {}}
- result = self._get_latest_version(card)
- assert result["version_id"] == "card-123_v1"
-
- def test_default_includes_headline(self):
- card = {"id": "c1", "title": "Headline", "metadata": {}}
- result = self._get_latest_version(card)
- assert result["headline"] == "Headline"
-
- def test_default_includes_summary(self):
- card = {"id": "c1", "title": "T", "summary": "Summary", "metadata": {}}
- result = self._get_latest_version(card)
- assert result["summary"] == "Summary"
-
- def test_default_includes_card_id(self):
- card = {"id": "c1", "title": "T", "metadata": {}}
- result = self._get_latest_version(card)
- assert result["card_id"] == "c1"
-
- def test_no_metadata_key(self):
- card = {"id": "c1", "title": "T"}
- result = self._get_latest_version(card)
- assert result["version_number"] == 1
diff --git a/tests/news/test_config_validation_patterns_behavior.py b/tests/news/test_config_validation_patterns_behavior.py
deleted file mode 100644
index 9a280da92a..0000000000
--- a/tests/news/test_config_validation_patterns_behavior.py
+++ /dev/null
@@ -1,657 +0,0 @@
-"""
-Deep behavioral tests for configuration validation patterns.
-Tests setting validation, type coercion, default values,
-and constraint checking logic.
-"""
-
-from datetime import datetime, timezone
-import re
-
-
-# --- Type validation patterns ---
-
-
-class TestTypeValidation:
- """Tests for configuration type validation."""
-
- def _validate_type(self, value, expected_type):
- """Validate value is of expected type."""
- if expected_type == "string":
- return isinstance(value, str)
- if expected_type == "int":
- return isinstance(value, int) and not isinstance(value, bool)
- if expected_type == "float":
- return isinstance(value, (int, float)) and not isinstance(
- value, bool
- )
- if expected_type == "bool":
- return isinstance(value, bool)
- if expected_type == "list":
- return isinstance(value, list)
- if expected_type == "dict":
- return isinstance(value, dict)
- return False
-
- def test_string_valid(self):
- assert self._validate_type("hello", "string") is True
-
- def test_string_not_int(self):
- assert self._validate_type(123, "string") is False
-
- def test_int_valid(self):
- assert self._validate_type(42, "int") is True
-
- def test_int_not_bool(self):
- assert self._validate_type(True, "int") is False
-
- def test_float_accepts_int(self):
- assert self._validate_type(42, "float") is True
-
- def test_float_accepts_float(self):
- assert self._validate_type(3.14, "float") is True
-
- def test_bool_valid(self):
- assert self._validate_type(True, "bool") is True
-
- def test_list_valid(self):
- assert self._validate_type([1, 2, 3], "list") is True
-
- def test_dict_valid(self):
- assert self._validate_type({"key": "value"}, "dict") is True
-
-
-class TestTypeCoercion:
- """Tests for configuration type coercion."""
-
- def _coerce_to_int(self, value, default=0):
- """Coerce value to integer."""
- if isinstance(value, bool):
- return 1 if value else 0
- try:
- return int(value)
- except (ValueError, TypeError):
- return default
-
- def _coerce_to_bool(self, value):
- """Coerce value to boolean."""
- if isinstance(value, bool):
- return value
- if isinstance(value, str):
- return value.lower() in ("true", "yes", "1", "on")
- if isinstance(value, (int, float)):
- return value != 0
- return bool(value)
-
- def _coerce_to_list(self, value):
- """Coerce value to list."""
- if isinstance(value, list):
- return value
- if isinstance(value, str):
- return [v.strip() for v in value.split(",") if v.strip()]
- if value is None:
- return []
- return [value]
-
- def test_int_from_string(self):
- assert self._coerce_to_int("42") == 42
-
- def test_int_from_float(self):
- assert self._coerce_to_int(3.7) == 3
-
- def test_int_invalid_uses_default(self):
- assert self._coerce_to_int("not a number", default=-1) == -1
-
- def test_bool_from_true_string(self):
- assert self._coerce_to_bool("true") is True
- assert self._coerce_to_bool("yes") is True
- assert self._coerce_to_bool("1") is True
-
- def test_bool_from_false_string(self):
- assert self._coerce_to_bool("false") is False
- assert self._coerce_to_bool("no") is False
-
- def test_list_from_csv(self):
- result = self._coerce_to_list("a, b, c")
- assert result == ["a", "b", "c"]
-
- def test_list_from_single(self):
- result = self._coerce_to_list("single")
- assert result == ["single"]
-
-
-# --- Range validation patterns ---
-
-
-class TestRangeValidation:
- """Tests for numeric range validation."""
-
- def _validate_range(self, value, min_val=None, max_val=None):
- """Validate value is within range."""
- if min_val is not None and value < min_val:
- return False
- if max_val is not None and value > max_val:
- return False
- return True
-
- def _clamp(self, value, min_val, max_val):
- """Clamp value to range."""
- return max(min_val, min(max_val, value))
-
- def test_within_range(self):
- assert self._validate_range(50, min_val=0, max_val=100) is True
-
- def test_at_min(self):
- assert self._validate_range(0, min_val=0, max_val=100) is True
-
- def test_at_max(self):
- assert self._validate_range(100, min_val=0, max_val=100) is True
-
- def test_below_min(self):
- assert self._validate_range(-1, min_val=0, max_val=100) is False
-
- def test_above_max(self):
- assert self._validate_range(101, min_val=0, max_val=100) is False
-
- def test_clamp_below(self):
- assert self._clamp(-10, 0, 100) == 0
-
- def test_clamp_above(self):
- assert self._clamp(150, 0, 100) == 100
-
- def test_clamp_within(self):
- assert self._clamp(50, 0, 100) == 50
-
-
-class TestLengthValidation:
- """Tests for string length validation."""
-
- def _validate_length(self, value, min_len=None, max_len=None):
- """Validate string length."""
- if not isinstance(value, str):
- return False
- length = len(value)
- if min_len is not None and length < min_len:
- return False
- if max_len is not None and length > max_len:
- return False
- return True
-
- def test_valid_length(self):
- assert self._validate_length("hello", min_len=1, max_len=10) is True
-
- def test_too_short(self):
- assert self._validate_length("", min_len=1, max_len=10) is False
-
- def test_too_long(self):
- assert self._validate_length("a" * 20, min_len=1, max_len=10) is False
-
- def test_non_string(self):
- assert self._validate_length(123, min_len=1) is False
-
-
-# --- Pattern validation patterns ---
-
-
-class TestPatternValidation:
- """Tests for pattern-based validation."""
-
- def _validate_email(self, value):
- """Validate email format."""
- pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
- return bool(re.match(pattern, value))
-
- def _validate_url(self, value):
- """Validate URL format."""
- pattern = r"^https?://[^\s/$.?#].[^\s]*$"
- return bool(re.match(pattern, value))
-
- def _validate_identifier(self, value):
- """Validate identifier format (alphanumeric with underscores)."""
- pattern = r"^[a-zA-Z][a-zA-Z0-9_]*$"
- return bool(re.match(pattern, value))
-
- def test_valid_email(self):
- assert self._validate_email("[email protected]") is True
-
- def test_invalid_email_no_at(self):
- assert self._validate_email("userexample.com") is False
-
- def test_invalid_email_no_domain(self):
- assert self._validate_email("user@") is False
-
- def test_valid_url_http(self):
- assert self._validate_url("http://example.com") is True
-
- def test_valid_url_https(self):
- assert self._validate_url("https://example.com/path") is True
-
- def test_invalid_url(self):
- assert self._validate_url("not a url") is False
-
- def test_valid_identifier(self):
- assert self._validate_identifier("valid_name") is True
-
- def test_invalid_identifier_starts_digit(self):
- assert self._validate_identifier("123invalid") is False
-
-
-# --- Enum validation patterns ---
-
-
-class TestEnumValidation:
- """Tests for enum/choice validation."""
-
- def _validate_choice(self, value, choices):
- """Validate value is in choices."""
- return value in choices
-
- def _validate_choice_case_insensitive(self, value, choices):
- """Validate choice case-insensitively."""
- if not isinstance(value, str):
- return value in choices
- lower_value = value.lower()
- return any(
- c.lower() == lower_value if isinstance(c, str) else c == value
- for c in choices
- )
-
- def test_valid_choice(self):
- assert self._validate_choice("red", ["red", "green", "blue"]) is True
-
- def test_invalid_choice(self):
- assert (
- self._validate_choice("yellow", ["red", "green", "blue"]) is False
- )
-
- def test_case_insensitive_match(self):
- assert (
- self._validate_choice_case_insensitive("RED", ["red", "green"])
- is True
- )
-
- def test_case_insensitive_no_match(self):
- assert (
- self._validate_choice_case_insensitive("YELLOW", ["red", "green"])
- is False
- )
-
-
-# --- Default value patterns ---
-
-
-class TestDefaultValues:
- """Tests for default value handling."""
-
- def _get_with_default(self, config, key, default=None):
- """Get config value with default."""
- value = config.get(key)
- if value is None:
- return default
- return value
-
- def _apply_defaults(self, config, defaults):
- """Apply defaults to config."""
- result = dict(defaults)
- result.update({k: v for k, v in config.items() if v is not None})
- return result
-
- def test_returns_value_if_present(self):
- config = {"key": "value"}
- assert self._get_with_default(config, "key", "default") == "value"
-
- def test_returns_default_if_missing(self):
- config = {}
- assert self._get_with_default(config, "key", "default") == "default"
-
- def test_returns_default_if_none(self):
- config = {"key": None}
- assert self._get_with_default(config, "key", "default") == "default"
-
- def test_apply_defaults(self):
- config = {"a": 1}
- defaults = {"a": 0, "b": 2}
- result = self._apply_defaults(config, defaults)
- assert result["a"] == 1
- assert result["b"] == 2
-
-
-# --- Nested config validation patterns ---
-
-
-class TestNestedConfigValidation:
- """Tests for nested configuration validation."""
-
- def _validate_nested(self, config, schema):
- """Validate nested config against schema."""
- errors = []
- for key, rules in schema.items():
- if rules.get("required") and key not in config:
- errors.append(f"Missing required field: {key}")
- continue
- if key not in config:
- continue
- value = config[key]
- expected_type = rules.get("type")
- if expected_type == "dict" and isinstance(value, dict):
- nested_schema = rules.get("schema", {})
- nested_errors = self._validate_nested(value, nested_schema)
- errors.extend([f"{key}.{e}" for e in nested_errors])
- elif expected_type and not isinstance(
- value,
- {"str": str, "int": int, "bool": bool, "dict": dict}.get(
- expected_type, type(None)
- ),
- ):
- errors.append(f"Invalid type for {key}")
- return errors
-
- def test_valid_nested(self):
- config = {"settings": {"enabled": True}}
- schema = {
- "settings": {
- "type": "dict",
- "schema": {"enabled": {"type": "bool"}},
- }
- }
- errors = self._validate_nested(config, schema)
- assert len(errors) == 0
-
- def test_missing_required(self):
- config = {}
- schema = {"name": {"required": True}}
- errors = self._validate_nested(config, schema)
- assert "Missing required field: name" in errors
-
-
-class TestConfigMerging:
- """Tests for config merging patterns."""
-
- def _deep_merge(self, base, override):
- """Deep merge two configs."""
- result = dict(base)
- for key, value in override.items():
- if (
- key in result
- and isinstance(result[key], dict)
- and isinstance(value, dict)
- ):
- result[key] = self._deep_merge(result[key], value)
- else:
- result[key] = value
- return result
-
- def test_shallow_merge(self):
- base = {"a": 1, "b": 2}
- override = {"b": 3, "c": 4}
- result = self._deep_merge(base, override)
- assert result == {"a": 1, "b": 3, "c": 4}
-
- def test_deep_merge(self):
- base = {"outer": {"a": 1, "b": 2}}
- override = {"outer": {"b": 3}}
- result = self._deep_merge(base, override)
- assert result["outer"]["a"] == 1
- assert result["outer"]["b"] == 3
-
-
-# --- Required field patterns ---
-
-
-class TestRequiredFields:
- """Tests for required field validation."""
-
- def _check_required(self, config, required_fields):
- """Check that required fields are present."""
- missing = []
- for field in required_fields:
- if field not in config or config[field] is None:
- missing.append(field)
- return missing
-
- def test_all_present(self):
- config = {"name": "test", "value": 42}
- missing = self._check_required(config, ["name", "value"])
- assert len(missing) == 0
-
- def test_some_missing(self):
- config = {"name": "test"}
- missing = self._check_required(config, ["name", "value"])
- assert missing == ["value"]
-
- def test_none_treated_as_missing(self):
- config = {"name": None}
- missing = self._check_required(config, ["name"])
- assert missing == ["name"]
-
-
-# --- Environment variable patterns ---
-
-
-class TestEnvVarPatterns:
- """Tests for environment variable handling patterns."""
-
- def _expand_env_vars(self, config, env):
- """Expand environment variable references in config."""
- result = {}
- for key, value in config.items():
- if (
- isinstance(value, str)
- and value.startswith("${")
- and value.endswith("}")
- ):
- env_key = value[2:-1]
- result[key] = env.get(env_key, value)
- elif isinstance(value, dict):
- result[key] = self._expand_env_vars(value, env)
- else:
- result[key] = value
- return result
-
- def _build_env_var_name(self, prefix, key):
- """Build environment variable name from config key."""
- return f"{prefix}_{key}".upper().replace("-", "_")
-
- def test_expands_env_var(self):
- config = {"api_key": "${API_KEY}"}
- env = {"API_KEY": "secret123"}
- result = self._expand_env_vars(config, env)
- assert result["api_key"] == "secret123"
-
- def test_keeps_original_if_missing(self):
- config = {"api_key": "${MISSING_KEY}"}
- env = {}
- result = self._expand_env_vars(config, env)
- assert result["api_key"] == "${MISSING_KEY}"
-
- def test_env_var_name_building(self):
- assert self._build_env_var_name("APP", "api-key") == "APP_API_KEY"
-
-
-# --- Validation result patterns ---
-
-
-class TestValidationResult:
- """Tests for validation result building patterns."""
-
- def _create_validation_result(self, errors=None, warnings=None):
- """Create a validation result."""
- return {
- "valid": len(errors or []) == 0,
- "errors": errors or [],
- "warnings": warnings or [],
- }
-
- def _merge_results(self, *results):
- """Merge multiple validation results."""
- all_errors = []
- all_warnings = []
- for result in results:
- all_errors.extend(result.get("errors", []))
- all_warnings.extend(result.get("warnings", []))
- return self._create_validation_result(all_errors, all_warnings)
-
- def test_valid_with_no_errors(self):
- result = self._create_validation_result()
- assert result["valid"] is True
-
- def test_invalid_with_errors(self):
- result = self._create_validation_result(errors=["Error 1"])
- assert result["valid"] is False
-
- def test_merge_combines_errors(self):
- r1 = self._create_validation_result(errors=["E1"])
- r2 = self._create_validation_result(errors=["E2"])
- merged = self._merge_results(r1, r2)
- assert len(merged["errors"]) == 2
-
-
-# --- Config file path patterns ---
-
-
-class TestConfigPathPatterns:
- """Tests for config file path resolution patterns."""
-
- def _resolve_path(self, base_path, relative_path):
- """Resolve relative path against base."""
- if relative_path.startswith("/"):
- return relative_path
- return f"{base_path.rstrip('/')}/{relative_path}"
-
- def _get_config_locations(self, app_name):
- """Get standard config locations."""
- return [
- f"/etc/{app_name}/config.yaml",
- f"~/.config/{app_name}/config.yaml",
- f"./{app_name}.yaml",
- "./config.yaml",
- ]
-
- def test_absolute_path_unchanged(self):
- result = self._resolve_path("/base", "/absolute/path")
- assert result == "/absolute/path"
-
- def test_relative_path_resolved(self):
- result = self._resolve_path("/base", "relative/path")
- assert result == "/base/relative/path"
-
- def test_config_locations(self):
- locations = self._get_config_locations("myapp")
- assert len(locations) == 4
- assert "/etc/myapp/config.yaml" in locations
-
-
-# --- Secret masking patterns ---
-
-
-class TestSecretMasking:
- """Tests for secret value masking patterns."""
-
- def _mask_secrets(self, config, secret_keys):
- """Mask secret values in config."""
- result = {}
- for key, value in config.items():
- if key in secret_keys:
- if isinstance(value, str) and len(value) > 0:
- result[key] = value[0] + "*" * (len(value) - 1)
- else:
- result[key] = "***"
- elif isinstance(value, dict):
- result[key] = self._mask_secrets(value, secret_keys)
- else:
- result[key] = value
- return result
-
- def _is_secret_key(self, key):
- """Check if key name suggests a secret."""
- secret_patterns = ["password", "secret", "key", "token", "credential"]
- key_lower = key.lower()
- return any(p in key_lower for p in secret_patterns)
-
- def test_masks_password(self):
- config = {"password": "secret123"}
- result = self._mask_secrets(config, ["password"])
- assert result["password"] == "s********"
-
- def test_preserves_non_secret(self):
- config = {"name": "test", "password": "secret"}
- result = self._mask_secrets(config, ["password"])
- assert result["name"] == "test"
-
- def test_is_secret_key(self):
- assert self._is_secret_key("api_key") is True
- assert self._is_secret_key("password") is True
- assert self._is_secret_key("username") is False
-
-
-# --- Config serialization patterns ---
-
-
-class TestConfigSerialization:
- """Tests for config serialization patterns."""
-
- def _prepare_for_json(self, config):
- """Prepare config for JSON serialization."""
- result = {}
- for key, value in config.items():
- if isinstance(value, datetime):
- result[key] = value.isoformat()
- elif isinstance(value, set):
- result[key] = list(value)
- elif isinstance(value, dict):
- result[key] = self._prepare_for_json(value)
- else:
- result[key] = value
- return result
-
- def test_converts_datetime(self):
- config = {"updated": datetime(2025, 6, 15, 12, 0, tzinfo=timezone.utc)}
- result = self._prepare_for_json(config)
- assert isinstance(result["updated"], str)
-
- def test_converts_set(self):
- config = {"tags": {"a", "b", "c"}}
- result = self._prepare_for_json(config)
- assert isinstance(result["tags"], list)
-
-
-# --- Config diff patterns ---
-
-
-class TestConfigDiff:
- """Tests for config difference detection patterns."""
-
- def _get_changes(self, old_config, new_config):
- """Get changes between configs."""
- changes = {"added": {}, "removed": {}, "modified": {}}
- all_keys = set(old_config.keys()) | set(new_config.keys())
- for key in all_keys:
- if key not in old_config:
- changes["added"][key] = new_config[key]
- elif key not in new_config:
- changes["removed"][key] = old_config[key]
- elif old_config[key] != new_config[key]:
- changes["modified"][key] = {
- "old": old_config[key],
- "new": new_config[key],
- }
- return changes
-
- def test_detects_added(self):
- old = {"a": 1}
- new = {"a": 1, "b": 2}
- changes = self._get_changes(old, new)
- assert "b" in changes["added"]
-
- def test_detects_removed(self):
- old = {"a": 1, "b": 2}
- new = {"a": 1}
- changes = self._get_changes(old, new)
- assert "b" in changes["removed"]
-
- def test_detects_modified(self):
- old = {"a": 1}
- new = {"a": 2}
- changes = self._get_changes(old, new)
- assert "a" in changes["modified"]
- assert changes["modified"]["a"]["old"] == 1
- assert changes["modified"]["a"]["new"] == 2
diff --git a/tests/news/test_configuration_patterns_behavior.py b/tests/news/test_configuration_patterns_behavior.py
deleted file mode 100644
index d370bf21a3..0000000000
--- a/tests/news/test_configuration_patterns_behavior.py
+++ /dev/null
@@ -1,774 +0,0 @@
-"""
-Behavioral tests for configuration patterns.
-
-These tests verify the logic of configuration patterns like loading,
-validation, merging, environment variables, and defaults
-without making actual file system or environment calls.
-"""
-
-import re
-from dataclasses import dataclass, field
-
-
-class TestConfigurationLoading:
- """Tests for configuration loading patterns."""
-
- def test_merge_configs(self):
- """Test merging multiple configuration sources."""
-
- def merge_configs(*configs):
- result = {}
- for config in configs:
- for key, value in config.items():
- if (
- key in result
- and isinstance(result[key], dict)
- and isinstance(value, dict)
- ):
- result[key] = merge_configs(result[key], value)
- else:
- result[key] = value
- return result
-
- base = {"debug": False, "database": {"host": "localhost", "port": 5432}}
- override = {"debug": True, "database": {"host": "production.db"}}
- result = merge_configs(base, override)
- assert result["debug"] is True
- assert result["database"]["host"] == "production.db"
- assert result["database"]["port"] == 5432
-
- def test_load_with_defaults(self):
- """Test loading config with default values."""
-
- def load_with_defaults(config, defaults):
- result = defaults.copy()
-
- def deep_update(base, updates):
- for key, value in updates.items():
- if (
- isinstance(value, dict)
- and key in base
- and isinstance(base[key], dict)
- ):
- deep_update(base[key], value)
- else:
- base[key] = value
-
- deep_update(result, config)
- return result
-
- defaults = {"timeout": 30, "retries": 3, "log_level": "INFO"}
- config = {"timeout": 60}
- result = load_with_defaults(config, defaults)
- assert result["timeout"] == 60
- assert result["retries"] == 3
-
- def test_config_precedence(self):
- """Test configuration source precedence."""
-
- def resolve_config(sources):
- # Sources in order: defaults, file, env, cli
- result = {}
- for source in sources:
- result.update(source)
- return result
-
- defaults = {"debug": False, "port": 8080}
- file_config = {"port": 9000}
- env_config = {"port": 8000}
- cli_config = {}
-
- result = resolve_config([defaults, file_config, env_config, cli_config])
- assert result["port"] == 8000 # Env overrides file
-
- def test_parse_dotted_key(self):
- """Test parsing dotted notation keys."""
-
- def set_nested(config, dotted_key, value):
- keys = dotted_key.split(".")
- current = config
- for key in keys[:-1]:
- if key not in current:
- current[key] = {}
- current = current[key]
- current[keys[-1]] = value
- return config
-
- config = {}
- set_nested(config, "database.host", "localhost")
- set_nested(config, "database.port", 5432)
- assert config["database"]["host"] == "localhost"
- assert config["database"]["port"] == 5432
-
- def test_get_nested_value(self):
- """Test getting nested config value."""
-
- def get_nested(config, dotted_key, default=None):
- keys = dotted_key.split(".")
- current = config
- for key in keys:
- if not isinstance(current, dict) or key not in current:
- return default
- current = current[key]
- return current
-
- config = {"database": {"host": "localhost", "port": 5432}}
- assert get_nested(config, "database.host") == "localhost"
- assert get_nested(config, "database.missing", "default") == "default"
- assert get_nested(config, "missing.nested") is None
-
-
-class TestEnvironmentVariables:
- """Tests for environment variable handling."""
-
- def test_parse_env_value(self):
- """Test parsing environment variable values."""
-
- def parse_env_value(value, value_type=str):
- if value_type is bool:
- return value.lower() in ("true", "1", "yes", "on")
- if value_type is int:
- return int(value)
- if value_type is float:
- return float(value)
- if value_type is list:
- return [v.strip() for v in value.split(",")]
- return value
-
- assert parse_env_value("true", bool) is True
- assert parse_env_value("false", bool) is False
- assert parse_env_value("42", int) == 42
- assert parse_env_value("3.14", float) == 3.14
- assert parse_env_value("a,b,c", list) == ["a", "b", "c"]
-
- def test_env_var_name_conversion(self):
- """Test converting config key to env var name."""
-
- def to_env_var_name(key, prefix=""):
- name = key.replace(".", "_").upper()
- if prefix:
- name = f"{prefix}_{name}"
- return name
-
- assert to_env_var_name("database.host") == "DATABASE_HOST"
- assert to_env_var_name("log_level", prefix="APP") == "APP_LOG_LEVEL"
-
- def test_expand_env_vars_in_string(self):
- """Test expanding environment variables in strings."""
-
- def expand_env_vars(value, env_vars):
- pattern = r"\$\{(\w+)\}"
- matches = re.findall(pattern, value)
- for var_name in matches:
- if var_name in env_vars:
- value = value.replace(
- f"${{{var_name}}}", env_vars[var_name]
- )
- return value
-
- env = {"HOST": "localhost", "PORT": "5432"}
- template = "postgres://user@${HOST}:${PORT}/db"
- result = expand_env_vars(template, env)
- assert result == "postgres://user@localhost:5432/db"
-
- def test_env_var_with_default(self):
- """Test environment variable with default value."""
-
- def get_env_with_default(env_vars, key, default=None):
- return env_vars.get(key, default)
-
- env = {"DEBUG": "true"}
- assert get_env_with_default(env, "DEBUG", "false") == "true"
- assert get_env_with_default(env, "MISSING", "default") == "default"
-
- def test_required_env_var(self):
- """Test required environment variable validation."""
-
- def validate_required_env(env_vars, required_vars):
- missing = [var for var in required_vars if var not in env_vars]
- return missing
-
- env = {"DB_HOST": "localhost"}
- required = ["DB_HOST", "DB_PASSWORD", "SECRET_KEY"]
- missing = validate_required_env(env, required)
- assert "DB_PASSWORD" in missing
- assert "SECRET_KEY" in missing
- assert "DB_HOST" not in missing
-
-
-class TestConfigValidation:
- """Tests for configuration validation."""
-
- def test_validate_required_fields(self):
- """Test validating required configuration fields."""
-
- def validate_required(config, required_fields):
- errors = []
- for field_name in required_fields:
- parts = field_name.split(".")
- current = config
- for part in parts:
- if not isinstance(current, dict) or part not in current:
- errors.append(f"Missing required field: {field_name}")
- break
- current = current[part]
- return errors
-
- config = {"database": {"host": "localhost"}}
- required = ["database.host", "database.port", "api_key"]
- errors = validate_required(config, required)
- assert "Missing required field: database.port" in errors
- assert "Missing required field: api_key" in errors
-
- def test_validate_type(self):
- """Test validating configuration value types."""
-
- def validate_types(config, type_spec):
- errors = []
- for key, expected_type in type_spec.items():
- if key in config:
- value = config[key]
- if not isinstance(value, expected_type):
- errors.append(
- f"{key}: expected {expected_type.__name__}, got {type(value).__name__}"
- )
- return errors
-
- config = {"port": "8080", "debug": True, "workers": 4}
- type_spec = {"port": int, "debug": bool, "workers": int}
- errors = validate_types(config, type_spec)
- assert "port: expected int, got str" in errors
-
- def test_validate_range(self):
- """Test validating numeric range."""
-
- def validate_range(value, min_val=None, max_val=None):
- if min_val is not None and value < min_val:
- return f"Value {value} is below minimum {min_val}"
- if max_val is not None and value > max_val:
- return f"Value {value} is above maximum {max_val}"
- return None
-
- assert validate_range(5, min_val=1, max_val=10) is None
- assert validate_range(0, min_val=1) is not None
- assert validate_range(15, max_val=10) is not None
-
- def test_validate_enum(self):
- """Test validating enum values."""
-
- def validate_enum(value, allowed_values):
- if value not in allowed_values:
- return (
- f"Value '{value}' not in allowed values: {allowed_values}"
- )
- return None
-
- assert validate_enum("DEBUG", ["DEBUG", "INFO", "WARNING"]) is None
- assert validate_enum("TRACE", ["DEBUG", "INFO", "WARNING"]) is not None
-
- def test_validate_pattern(self):
- """Test validating string patterns."""
-
- def validate_pattern(value, pattern):
- if not re.match(pattern, value):
- return f"Value '{value}' does not match pattern '{pattern}'"
- return None
-
- email_pattern = r"^[\w.-]+@[\w.-]+\.\w+$"
- assert validate_pattern("[email protected]", email_pattern) is None
- assert validate_pattern("invalid", email_pattern) is not None
-
-
-class TestConfigDefaults:
- """Tests for configuration default values."""
-
- def test_apply_defaults(self):
- """Test applying default values."""
-
- def apply_defaults(config, defaults):
- result = {}
- for key, default_value in defaults.items():
- if key in config:
- if isinstance(default_value, dict) and isinstance(
- config[key], dict
- ):
- result[key] = apply_defaults(config[key], default_value)
- else:
- result[key] = config[key]
- else:
- result[key] = default_value
- # Include any keys not in defaults
- for key in config:
- if key not in result:
- result[key] = config[key]
- return result
-
- defaults = {"timeout": 30, "retries": 3, "options": {"verbose": False}}
- config = {"timeout": 60, "extra": "value"}
- result = apply_defaults(config, defaults)
- assert result["timeout"] == 60
- assert result["retries"] == 3
- assert result["extra"] == "value"
-
- def test_lazy_defaults(self):
- """Test lazy default value evaluation."""
-
- def get_with_lazy_default(config, key, default_fn):
- if key in config:
- return config[key]
- return default_fn()
-
- config = {"name": "John"}
- # Default function is only called if key is missing
- call_count = {"count": 0}
-
- def expensive_default():
- call_count["count"] += 1
- return "computed"
-
- result1 = get_with_lazy_default(config, "name", expensive_default)
- assert result1 == "John"
- assert call_count["count"] == 0 # Not called
-
- result2 = get_with_lazy_default(config, "missing", expensive_default)
- assert result2 == "computed"
- assert call_count["count"] == 1
-
- def test_conditional_defaults(self):
- """Test conditional default values."""
-
- def get_conditional_default(config, env):
- defaults = {
- "development": {"debug": True, "log_level": "DEBUG"},
- "production": {"debug": False, "log_level": "WARNING"},
- }
- return defaults.get(env, defaults["development"])
-
- dev_defaults = get_conditional_default({}, "development")
- assert dev_defaults["debug"] is True
-
- prod_defaults = get_conditional_default({}, "production")
- assert prod_defaults["debug"] is False
-
- def test_default_factory(self):
- """Test default value factory functions."""
-
- @dataclass
- class Config:
- name: str = "default"
- tags: list = field(default_factory=list)
- settings: dict = field(default_factory=dict)
-
- config1 = Config()
- config2 = Config()
-
- # Factory creates new instances
- config1.tags.append("test")
- assert config2.tags == [] # Not affected
-
- def test_inherit_defaults(self):
- """Test inheriting defaults from parent config."""
-
- def inherit_defaults(child, parent):
- result = parent.copy()
- result.update(child)
- return result
-
- parent = {"timeout": 30, "retries": 3}
- child = {"timeout": 60, "custom": True}
- result = inherit_defaults(child, parent)
- assert result["timeout"] == 60
- assert result["retries"] == 3
- assert result["custom"] is True
-
-
-class TestConfigProfiles:
- """Tests for configuration profiles/environments."""
-
- def test_load_profile(self):
- """Test loading configuration profile."""
-
- def load_profile(configs, profile_name):
- base = configs.get("base", {})
- profile = configs.get(profile_name, {})
- return {**base, **profile}
-
- configs = {
- "base": {"app_name": "MyApp", "debug": False},
- "development": {"debug": True, "database": "dev.db"},
- "production": {"database": "prod.db"},
- }
-
- dev_config = load_profile(configs, "development")
- assert dev_config["debug"] is True
- assert dev_config["app_name"] == "MyApp"
-
- prod_config = load_profile(configs, "production")
- assert prod_config["debug"] is False
-
- def test_detect_environment(self):
- """Test detecting current environment."""
-
- def detect_environment(env_vars, default="development"):
- env_names = ["ENV", "ENVIRONMENT", "NODE_ENV", "APP_ENV"]
- for name in env_names:
- if name in env_vars:
- return env_vars[name]
- return default
-
- assert detect_environment({"ENV": "production"}) == "production"
- assert detect_environment({"NODE_ENV": "test"}) == "test"
- assert detect_environment({}) == "development"
-
- def test_profile_override(self):
- """Test overriding specific profile settings."""
-
- def apply_override(config, overrides, env):
- # Apply base config
- result = config.get("base", {}).copy()
- # Apply environment-specific
- result.update(config.get(env, {}))
- # Apply overrides
- result.update(overrides)
- return result
-
- config = {
- "base": {"debug": False, "port": 8080},
- "development": {"debug": True},
- }
- overrides = {"port": 9000}
- result = apply_override(config, overrides, "development")
- assert result["debug"] is True
- assert result["port"] == 9000
-
- def test_feature_flags(self):
- """Test feature flag configuration."""
-
- def is_feature_enabled(features, feature_name, default=False):
- return features.get(feature_name, default)
-
- features = {"new_ui": True, "beta_api": False}
- assert is_feature_enabled(features, "new_ui") is True
- assert is_feature_enabled(features, "beta_api") is False
- assert is_feature_enabled(features, "missing", default=True) is True
-
- def test_toggle_features_by_env(self):
- """Test toggling features by environment."""
-
- def get_features(env):
- features = {
- "development": {"debug_toolbar": True, "mock_api": True},
- "production": {"debug_toolbar": False, "mock_api": False},
- }
- return features.get(env, features["production"])
-
- dev_features = get_features("development")
- assert dev_features["debug_toolbar"] is True
-
- prod_features = get_features("production")
- assert prod_features["debug_toolbar"] is False
-
-
-class TestConfigSecrets:
- """Tests for handling sensitive configuration."""
-
- def test_mask_secret_values(self):
- """Test masking secret values in output."""
-
- def mask_secrets(config, secret_keys):
- result = {}
- for key, value in config.items():
- if key in secret_keys:
- result[key] = "***MASKED***"
- elif isinstance(value, dict):
- result[key] = mask_secrets(value, secret_keys)
- else:
- result[key] = value
- return result
-
- config = {
- "database": {"host": "localhost", "password": "secret123"},
- "api_key": "abc123",
- }
- masked = mask_secrets(config, {"password", "api_key"})
- assert masked["database"]["password"] == "***MASKED***"
- assert masked["api_key"] == "***MASKED***"
- assert masked["database"]["host"] == "localhost"
-
- def test_detect_secrets_in_config(self):
- """Test detecting potential secrets in config."""
-
- def detect_secrets(config, secret_patterns):
- findings = []
- for key, value in config.items():
- if isinstance(value, dict):
- findings.extend(detect_secrets(value, secret_patterns))
- elif isinstance(value, str):
- for pattern in secret_patterns:
- if re.match(pattern, key, re.IGNORECASE):
- findings.append(key)
- break
- return findings
-
- patterns = [
- r".*password.*",
- r".*secret.*",
- r".*api_key.*",
- r".*token.*",
- ]
- config = {
- "db_password": "secret",
- "user_name": "john",
- "api_token": "abc123",
- }
- secrets = detect_secrets(config, patterns)
- assert "db_password" in secrets
- assert "api_token" in secrets
- assert "user_name" not in secrets
-
- def test_validate_secret_strength(self):
- """Test validating secret strength."""
-
- def validate_secret_strength(secret, min_length=8):
- errors = []
- if len(secret) < min_length:
- errors.append(f"Must be at least {min_length} characters")
- if not re.search(r"[A-Z]", secret):
- errors.append("Must contain uppercase letter")
- if not re.search(r"[a-z]", secret):
- errors.append("Must contain lowercase letter")
- if not re.search(r"\d", secret):
- errors.append("Must contain digit")
- return errors
-
- errors = validate_secret_strength("weak")
- assert len(errors) > 0
-
- errors = validate_secret_strength("StrongPass123")
- assert len(errors) == 0
-
- def test_rotate_secret_check(self):
- """Test checking if secret needs rotation."""
- import time
-
- def needs_rotation(secret_metadata, max_age_days=90):
- created_at = secret_metadata.get("created_at", 0)
- age_days = (time.time() - created_at) / (24 * 3600)
- return age_days > max_age_days
-
- old_secret = {"created_at": time.time() - (100 * 24 * 3600)}
- new_secret = {"created_at": time.time()}
-
- assert needs_rotation(old_secret) is True
- assert needs_rotation(new_secret) is False
-
-
-class TestConfigSchema:
- """Tests for configuration schema validation."""
-
- def test_schema_definition(self):
- """Test defining configuration schema."""
-
- schema = {
- "type": "object",
- "properties": {
- "name": {"type": "string", "required": True},
- "port": {"type": "integer", "min": 1, "max": 65535},
- "debug": {"type": "boolean", "default": False},
- },
- }
-
- def validate_property(value, prop_schema):
- prop_type = prop_schema.get("type")
- if prop_type == "string" and not isinstance(value, str):
- return f"Expected string, got {type(value).__name__}"
- if prop_type == "integer" and not isinstance(value, int):
- return f"Expected integer, got {type(value).__name__}"
- if prop_type == "boolean" and not isinstance(value, bool):
- return f"Expected boolean, got {type(value).__name__}"
- if "min" in prop_schema and value < prop_schema["min"]:
- return f"Value {value} below minimum {prop_schema['min']}"
- if "max" in prop_schema and value > prop_schema["max"]:
- return f"Value {value} above maximum {prop_schema['max']}"
- return None
-
- assert validate_property("test", schema["properties"]["name"]) is None
- assert validate_property(8080, schema["properties"]["port"]) is None
- assert (
- validate_property(70000, schema["properties"]["port"]) is not None
- )
-
- def test_nested_schema_validation(self):
- """Test nested schema validation."""
-
- def validate_nested(config, schema):
- errors = []
- for key, value in config.items():
- if key not in schema:
- continue
- prop_schema = schema[key]
- if prop_schema.get("type") == "object" and isinstance(
- value, dict
- ):
- nested_errors = validate_nested(
- value, prop_schema.get("properties", {})
- )
- errors.extend([f"{key}.{e}" for e in nested_errors])
- elif prop_schema.get("type") == "string" and not isinstance(
- value, str
- ):
- errors.append(f"{key}: expected string")
- elif prop_schema.get("type") == "integer" and not isinstance(
- value, int
- ):
- errors.append(f"{key}: expected integer")
- return errors
-
- schema = {
- "database": {
- "type": "object",
- "properties": {
- "host": {"type": "string"},
- "port": {"type": "integer"},
- },
- }
- }
- config = {
- "database": {"host": "localhost", "port": "5432"}
- } # port is string
- errors = validate_nested(config, schema)
- assert "database.port: expected integer" in errors
-
- def test_array_schema_validation(self):
- """Test array schema validation."""
-
- def validate_array(value, item_schema):
- if not isinstance(value, list):
- return "Expected array"
- errors = []
- for i, item in enumerate(value):
- if item_schema.get("type") == "string" and not isinstance(
- item, str
- ):
- errors.append(f"Item {i}: expected string")
- if item_schema.get("type") == "integer" and not isinstance(
- item, int
- ):
- errors.append(f"Item {i}: expected integer")
- return errors if errors else None
-
- assert validate_array(["a", "b", "c"], {"type": "string"}) is None
- errors = validate_array(["a", 1, "c"], {"type": "string"})
- assert "Item 1: expected string" in errors
-
- def test_apply_schema_defaults(self):
- """Test applying schema defaults."""
-
- def apply_schema_defaults(config, schema):
- result = config.copy()
- for key, prop_schema in schema.items():
- if key not in result and "default" in prop_schema:
- result[key] = prop_schema["default"]
- elif prop_schema.get("type") == "object" and key in result:
- result[key] = apply_schema_defaults(
- result[key], prop_schema.get("properties", {})
- )
- return result
-
- schema = {
- "debug": {"type": "boolean", "default": False},
- "timeout": {"type": "integer", "default": 30},
- }
- config = {"debug": True}
- result = apply_schema_defaults(config, schema)
- assert result["debug"] is True
- assert result["timeout"] == 30
-
-
-class TestConfigurationWatch:
- """Tests for configuration watching/reloading."""
-
- def test_detect_config_changes(self):
- """Test detecting configuration changes."""
-
- def has_changed(old_config, new_config):
- return old_config != new_config
-
- old = {"debug": True, "port": 8080}
- new_same = {"debug": True, "port": 8080}
- new_different = {"debug": True, "port": 9000}
-
- assert has_changed(old, new_same) is False
- assert has_changed(old, new_different) is True
-
- def test_diff_configs(self):
- """Test getting differences between configs."""
-
- def diff_configs(old_config, new_config):
- changes = {"added": {}, "removed": {}, "modified": {}}
- all_keys = set(old_config.keys()) | set(new_config.keys())
-
- for key in all_keys:
- if key not in old_config:
- changes["added"][key] = new_config[key]
- elif key not in new_config:
- changes["removed"][key] = old_config[key]
- elif old_config[key] != new_config[key]:
- changes["modified"][key] = {
- "old": old_config[key],
- "new": new_config[key],
- }
- return changes
-
- old = {"a": 1, "b": 2, "c": 3}
- new = {"a": 1, "b": 5, "d": 4}
- diff = diff_configs(old, new)
- assert "d" in diff["added"]
- assert "c" in diff["removed"]
- assert "b" in diff["modified"]
-
- def test_notify_config_change(self):
- """Test notifying on config change."""
-
- class ConfigWatcher:
- def __init__(self):
- self.callbacks = []
-
- def on_change(self, callback):
- self.callbacks.append(callback)
-
- def notify(self, old_config, new_config):
- for callback in self.callbacks:
- callback(old_config, new_config)
-
- watcher = ConfigWatcher()
- changes = []
- watcher.on_change(lambda old, new: changes.append((old, new)))
-
- watcher.notify({"a": 1}, {"a": 2})
- assert len(changes) == 1
- assert changes[0] == ({"a": 1}, {"a": 2})
-
- def test_hot_reload_safety(self):
- """Test safe hot reload validation."""
-
- def can_hot_reload(changed_keys, hot_reloadable_keys):
- # Check if all changed keys can be hot reloaded
- return all(key in hot_reloadable_keys for key in changed_keys)
-
- hot_reloadable = {"log_level", "cache_ttl", "feature_flags"}
- assert can_hot_reload(["log_level"], hot_reloadable) is True
- assert can_hot_reload(["database_url"], hot_reloadable) is False
-
- def test_config_version(self):
- """Test configuration versioning."""
-
- def bump_version(config):
- version = config.get("_version", 0)
- return {**config, "_version": version + 1}
-
- config = {"debug": True}
- v1 = bump_version(config)
- v2 = bump_version(v1)
- assert v1["_version"] == 1
- assert v2["_version"] == 2
diff --git a/tests/news/test_content_formatting_patterns_behavior.py b/tests/news/test_content_formatting_patterns_behavior.py
deleted file mode 100644
index ce924aa096..0000000000
--- a/tests/news/test_content_formatting_patterns_behavior.py
+++ /dev/null
@@ -1,587 +0,0 @@
-"""
-Deep behavioral tests for content formatting patterns.
-Tests markdown conversion, HTML sanitization, date formatting,
-and number formatting logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-import re
-
-
-# --- Markdown formatting patterns ---
-
-
-class TestMarkdownFormatting:
- """Tests for markdown formatting patterns."""
-
- def _bold(self, text):
- """Make text bold in markdown."""
- return f"**{text}**"
-
- def _italic(self, text):
- """Make text italic in markdown."""
- return f"*{text}*"
-
- def _code(self, text):
- """Make text code in markdown."""
- return f"`{text}`"
-
- def _link(self, text, url):
- """Create markdown link."""
- return f"[{text}]({url})"
-
- def _heading(self, text, level=1):
- """Create markdown heading."""
- return f"{'#' * level} {text}"
-
- def test_bold(self):
- result = self._bold("hello")
- assert result == "**hello**"
-
- def test_italic(self):
- result = self._italic("hello")
- assert result == "*hello*"
-
- def test_code(self):
- result = self._code("print()")
- assert result == "`print()`"
-
- def test_link(self):
- result = self._link("Click here", "https://example.com")
- assert result == "[Click here](https://example.com)"
-
- def test_heading_h1(self):
- result = self._heading("Title", 1)
- assert result == "# Title"
-
- def test_heading_h3(self):
- result = self._heading("Section", 3)
- assert result == "### Section"
-
-
-class TestMarkdownLists:
- """Tests for markdown list formatting."""
-
- def _bullet_list(self, items):
- """Create bullet list."""
- return "\n".join(f"- {item}" for item in items)
-
- def _numbered_list(self, items):
- """Create numbered list."""
- return "\n".join(f"{i + 1}. {item}" for i, item in enumerate(items))
-
- def _checkbox_list(self, items, checked=None):
- """Create checkbox list."""
- checked = checked or []
- lines = []
- for i, item in enumerate(items):
- box = "[x]" if i in checked else "[ ]"
- lines.append(f"- {box} {item}")
- return "\n".join(lines)
-
- def test_bullet_list(self):
- result = self._bullet_list(["one", "two", "three"])
- assert "- one" in result
- assert "- two" in result
-
- def test_numbered_list(self):
- result = self._numbered_list(["first", "second"])
- assert "1. first" in result
- assert "2. second" in result
-
- def test_checkbox_unchecked(self):
- result = self._checkbox_list(["task"])
- assert "[ ] task" in result
-
- def test_checkbox_checked(self):
- result = self._checkbox_list(["task"], checked=[0])
- assert "[x] task" in result
-
-
-# --- HTML sanitization patterns ---
-
-
-class TestHTMLSanitization:
- """Tests for HTML sanitization patterns."""
-
- def _strip_tags(self, html):
- """Remove all HTML tags."""
- return re.sub(r"<[^>]+>", "", html)
-
- def _escape_html(self, text):
- """Escape HTML special characters."""
- escapes = {
- "&": "&amp;",
- "<": "&lt;",
- ">": "&gt;",
- '"': "&quot;",
- "'": "&#39;",
- }
- for char, escape in escapes.items():
- text = text.replace(char, escape)
- return text
-
- def _sanitize_html(self, html, allowed_tags=None):
- """Sanitize HTML keeping only allowed tags."""
- allowed_tags = allowed_tags or ["p", "b", "i", "a", "br"]
- # Remove script tags completely
- html = re.sub(r"<script[^>]*>.*?</script>", "", html, flags=re.DOTALL)
- # Remove style tags completely
- html = re.sub(r"<style[^>]*>.*?</style>", "", html, flags=re.DOTALL)
- return html
-
- def test_strip_all_tags(self):
- result = self._strip_tags("<p>Hello <b>World</b></p>")
- assert result == "Hello World"
-
- def test_escape_special_chars(self):
- result = self._escape_html("<script>alert('xss')</script>")
- assert "<" not in result
- assert "&lt;" in result
-
- def test_sanitize_removes_script(self):
- result = self._sanitize_html("<p>Safe</p><script>evil()</script>")
- assert "<script>" not in result
- assert "Safe" in result
-
-
-# --- Date formatting patterns ---
-
-
-class TestDateFormatting:
- """Tests for date formatting patterns."""
-
- def _format_date(self, dt, format_str="%Y-%m-%d"):
- """Format date to string."""
- if not dt:
- return ""
- return dt.strftime(format_str)
-
- def _format_datetime(self, dt, format_str="%Y-%m-%d %H:%M:%S"):
- """Format datetime to string."""
- if not dt:
- return ""
- return dt.strftime(format_str)
-
- def _format_iso(self, dt):
- """Format datetime to ISO 8601."""
- if not dt:
- return ""
- return dt.isoformat()
-
- def test_format_date(self):
- dt = datetime(2025, 6, 15, tzinfo=timezone.utc)
- result = self._format_date(dt)
- assert result == "2025-06-15"
-
- def test_format_datetime(self):
- dt = datetime(2025, 6, 15, 14, 30, 0, tzinfo=timezone.utc)
- result = self._format_datetime(dt)
- assert "2025-06-15" in result
- assert "14:30:00" in result
-
- def test_format_iso(self):
- dt = datetime(2025, 6, 15, 14, 30, 0, tzinfo=timezone.utc)
- result = self._format_iso(dt)
- assert "2025-06-15" in result
- assert "T" in result
-
-
-class TestRelativeDateFormatting:
- """Tests for relative date formatting patterns."""
-
- def _format_relative(self, dt):
- """Format datetime as relative time."""
- if not dt:
- return "unknown"
- now = datetime.now(timezone.utc)
- diff = now - dt
- seconds = diff.total_seconds()
- if seconds < 0:
- return "in the future"
- if seconds < 60:
- return "just now"
- minutes = seconds / 60
- if minutes < 60:
- return f"{int(minutes)} minute{'s' if minutes >= 2 else ''} ago"
- hours = minutes / 60
- if hours < 24:
- return f"{int(hours)} hour{'s' if hours >= 2 else ''} ago"
- days = hours / 24
- if days < 30:
- return f"{int(days)} day{'s' if days >= 2 else ''} ago"
- months = days / 30
- if months < 12:
- return f"{int(months)} month{'s' if months >= 2 else ''} ago"
- years = days / 365
- return f"{int(years)} year{'s' if years >= 2 else ''} ago"
-
- def test_just_now(self):
- dt = datetime.now(timezone.utc) - timedelta(seconds=30)
- result = self._format_relative(dt)
- assert result == "just now"
-
- def test_minutes_ago(self):
- dt = datetime.now(timezone.utc) - timedelta(minutes=5)
- result = self._format_relative(dt)
- assert "5 minutes ago" in result
-
- def test_hours_ago(self):
- dt = datetime.now(timezone.utc) - timedelta(hours=3)
- result = self._format_relative(dt)
- assert "3 hours ago" in result
-
- def test_days_ago(self):
- dt = datetime.now(timezone.utc) - timedelta(days=2)
- result = self._format_relative(dt)
- assert "2 days ago" in result
-
-
-# --- Number formatting patterns ---
-
-
-class TestNumberFormatting:
- """Tests for number formatting patterns."""
-
- def _format_number(self, num, decimals=0):
- """Format number with thousands separator."""
- if decimals > 0:
- return f"{num:,.{decimals}f}"
- return f"{num:,}"
-
- def _format_percentage(self, num, decimals=1):
- """Format number as percentage."""
- return f"{num:.{decimals}f}%"
-
- def _format_currency(self, num, symbol="$", decimals=2):
- """Format number as currency."""
- return f"{symbol}{num:,.{decimals}f}"
-
- def test_format_thousands(self):
- result = self._format_number(1234567)
- assert result == "1,234,567"
-
- def test_format_with_decimals(self):
- result = self._format_number(1234.5678, decimals=2)
- assert result == "1,234.57"
-
- def test_format_percentage(self):
- result = self._format_percentage(75.5)
- assert result == "75.5%"
-
- def test_format_currency(self):
- result = self._format_currency(1234.56)
- assert result == "$1,234.56"
-
-
-class TestCompactNumberFormatting:
- """Tests for compact number formatting patterns."""
-
- def _format_compact(self, num):
- """Format large numbers compactly."""
- if num >= 1_000_000_000:
- return f"{num / 1_000_000_000:.1f}B"
- if num >= 1_000_000:
- return f"{num / 1_000_000:.1f}M"
- if num >= 1_000:
- return f"{num / 1_000:.1f}K"
- return str(num)
-
- def _format_bytes(self, size):
- """Format bytes to human readable."""
- for unit in ["B", "KB", "MB", "GB", "TB"]:
- if size < 1024:
- return f"{size:.1f} {unit}"
- size /= 1024
- return f"{size:.1f} PB"
-
- def test_format_thousands(self):
- result = self._format_compact(1500)
- assert result == "1.5K"
-
- def test_format_millions(self):
- result = self._format_compact(2500000)
- assert result == "2.5M"
-
- def test_format_billions(self):
- result = self._format_compact(3000000000)
- assert result == "3.0B"
-
- def test_format_bytes_kb(self):
- result = self._format_bytes(2048)
- assert "KB" in result
-
- def test_format_bytes_mb(self):
- result = self._format_bytes(5 * 1024 * 1024)
- assert "MB" in result
-
-
-# --- Text case formatting patterns ---
-
-
-class TestTextCaseFormatting:
- """Tests for text case formatting patterns."""
-
- def _to_title_case(self, text):
- """Convert to title case."""
- return text.title()
-
- def _to_sentence_case(self, text):
- """Convert to sentence case."""
- if not text:
- return ""
- return text[0].upper() + text[1:].lower()
-
- def _to_snake_case(self, text):
- """Convert to snake_case."""
- # Insert underscore before uppercase letters
- result = re.sub(r"([A-Z])", r"_\1", text)
- # Replace spaces and hyphens with underscores
- result = re.sub(r"[\s-]+", "_", result)
- # Collapse multiple underscores
- result = re.sub(r"_+", "_", result)
- # Remove leading underscore and lowercase
- return result.strip("_").lower()
-
- def _to_camel_case(self, text):
- """Convert to camelCase."""
- words = re.split(r"[\s_-]+", text)
- if not words:
- return ""
- return words[0].lower() + "".join(w.title() for w in words[1:])
-
- def _to_kebab_case(self, text):
- """Convert to kebab-case."""
- result = re.sub(r"([A-Z])", r"-\1", text)
- result = re.sub(r"[\s_]+", "-", result)
- # Collapse multiple hyphens
- result = re.sub(r"-+", "-", result)
- return result.strip("-").lower()
-
- def test_title_case(self):
- result = self._to_title_case("hello world")
- assert result == "Hello World"
-
- def test_sentence_case(self):
- result = self._to_sentence_case("HELLO WORLD")
- assert result == "Hello world"
-
- def test_snake_case(self):
- result = self._to_snake_case("Hello World")
- assert result == "hello_world"
-
- def test_camel_case(self):
- result = self._to_camel_case("hello world")
- assert result == "helloWorld"
-
- def test_kebab_case(self):
- result = self._to_kebab_case("Hello World")
- assert result == "hello-world"
-
-
-# --- URL formatting patterns ---
-
-
-class TestURLFormatting:
- """Tests for URL formatting patterns."""
-
- def _format_url(self, base, path="", params=None):
- """Format URL with path and params."""
- url = base.rstrip("/")
- if path:
- url += "/" + path.lstrip("/")
- if params:
- query = "&".join(f"{k}={v}" for k, v in params.items())
- url += "?" + query
- return url
-
- def _slugify(self, text):
- """Convert text to URL-safe slug."""
- # Lowercase and replace spaces with hyphens
- slug = text.lower().replace(" ", "-")
- # Remove non-alphanumeric characters except hyphens
- slug = re.sub(r"[^a-z0-9-]", "", slug)
- # Remove multiple consecutive hyphens
- slug = re.sub(r"-+", "-", slug)
- return slug.strip("-")
-
- def _extract_domain(self, url):
- """Extract domain from URL."""
- match = re.match(r"https?://([^/]+)", url)
- return match.group(1) if match else None
-
- def test_format_simple_url(self):
- result = self._format_url("https://example.com")
- assert result == "https://example.com"
-
- def test_format_url_with_path(self):
- result = self._format_url("https://example.com", "api/users")
- assert result == "https://example.com/api/users"
-
- def test_format_url_with_params(self):
- result = self._format_url("https://example.com", "", {"page": 1})
- assert "?page=1" in result
-
- def test_slugify(self):
- result = self._slugify("Hello World! This is a Test")
- assert result == "hello-world-this-is-a-test"
-
- def test_extract_domain(self):
- result = self._extract_domain("https://example.com/path")
- assert result == "example.com"
-
-
-# --- JSON formatting patterns ---
-
-
-class TestJSONFormatting:
- """Tests for JSON formatting patterns."""
-
- def _format_json_value(self, value):
- """Format value for JSON output."""
- if value is None:
- return "null"
- if isinstance(value, bool):
- return "true" if value else "false"
- if isinstance(value, str):
- return f'"{value}"'
- if isinstance(value, (int, float)):
- return str(value)
- if isinstance(value, list):
- items = ", ".join(self._format_json_value(v) for v in value)
- return f"[{items}]"
- if isinstance(value, dict):
- pairs = ", ".join(
- f'"{k}": {self._format_json_value(v)}' for k, v in value.items()
- )
- return "{" + pairs + "}"
- return str(value)
-
- def test_format_string(self):
- result = self._format_json_value("hello")
- assert result == '"hello"'
-
- def test_format_number(self):
- result = self._format_json_value(42)
- assert result == "42"
-
- def test_format_bool(self):
- assert self._format_json_value(True) == "true"
- assert self._format_json_value(False) == "false"
-
- def test_format_null(self):
- result = self._format_json_value(None)
- assert result == "null"
-
- def test_format_list(self):
- result = self._format_json_value([1, 2, 3])
- assert result == "[1, 2, 3]"
-
-
-# --- Table formatting patterns ---
-
-
-class TestTableFormatting:
- """Tests for table formatting patterns."""
-
- def _format_table(self, headers, rows, separator="|"):
- """Format data as ASCII table."""
- # Calculate column widths
- widths = [len(h) for h in headers]
- for row in rows:
- for i, cell in enumerate(row):
- widths[i] = max(widths[i], len(str(cell)))
- # Format header
- header_line = separator.join(
- str(h).ljust(widths[i]) for i, h in enumerate(headers)
- )
- separator_line = separator.join("-" * w for w in widths)
- # Format rows
- row_lines = []
- for row in rows:
- line = separator.join(
- str(cell).ljust(widths[i]) for i, cell in enumerate(row)
- )
- row_lines.append(line)
- return "\n".join([header_line, separator_line] + row_lines)
-
- def _format_csv_row(self, values, delimiter=","):
- """Format values as CSV row."""
- formatted = []
- for v in values:
- s = str(v)
- if delimiter in s or '"' in s or "\n" in s:
- s = '"' + s.replace('"', '""') + '"'
- formatted.append(s)
- return delimiter.join(formatted)
-
- def test_format_simple_table(self):
- headers = ["Name", "Age"]
- rows = [["Alice", 30], ["Bob", 25]]
- result = self._format_table(headers, rows)
- assert "Name" in result
- assert "Alice" in result
-
- def test_csv_simple(self):
- result = self._format_csv_row(["a", "b", "c"])
- assert result == "a,b,c"
-
- def test_csv_with_comma(self):
- result = self._format_csv_row(["hello, world", "test"])
- assert '"hello, world"' in result
-
-
-# --- Pluralization patterns ---
-
-
-class TestPluralization:
- """Tests for pluralization patterns."""
-
- def _pluralize(self, word, count):
- """Simple pluralization."""
- if count == 1:
- return word
- # Handle common irregular plurals
- irregulars = {
- "child": "children",
- "person": "people",
- "mouse": "mice",
- }
- if word in irregulars:
- return irregulars[word]
- # Handle common suffixes
- if word.endswith("y"):
- return word[:-1] + "ies"
- if word.endswith(("s", "sh", "ch", "x", "z")):
- return word + "es"
- return word + "s"
-
- def _format_count(self, count, singular, plural=None):
- """Format count with proper noun."""
- plural = plural or self._pluralize(singular, 2)
- noun = singular if count == 1 else plural
- return f"{count} {noun}"
-
- def test_regular_plural(self):
- result = self._pluralize("cat", 2)
- assert result == "cats"
-
- def test_singular(self):
- result = self._pluralize("cat", 1)
- assert result == "cat"
-
- def test_y_ending(self):
- result = self._pluralize("category", 2)
- assert result == "categories"
-
- def test_irregular(self):
- result = self._pluralize("child", 2)
- assert result == "children"
-
- def test_format_count(self):
- result = self._format_count(5, "item")
- assert result == "5 items"
-
- def test_format_count_singular(self):
- result = self._format_count(1, "item")
- assert result == "1 item"
diff --git a/tests/news/test_data_aggregation_patterns_behavior.py b/tests/news/test_data_aggregation_patterns_behavior.py
deleted file mode 100644
index 01208bd0a8..0000000000
--- a/tests/news/test_data_aggregation_patterns_behavior.py
+++ /dev/null
@@ -1,644 +0,0 @@
-"""
-Deep behavioral tests for data aggregation patterns.
-Tests counting, summing, averaging, grouping,
-and statistical calculation logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-from collections import defaultdict
-import math
-
-
-# --- Basic aggregation patterns ---
-
-
-class TestCountAggregation:
- """Tests for count aggregation patterns."""
-
- def _count_items(self, items):
- """Count total items."""
- return len(items)
-
- def _count_by_field(self, items, field):
- """Count items grouped by field."""
- counts = defaultdict(int)
- for item in items:
- key = item.get(field)
- counts[key] += 1
- return dict(counts)
-
- def _count_if(self, items, predicate):
- """Count items matching predicate."""
- return sum(1 for item in items if predicate(item))
-
- def test_count_all(self):
- items = [1, 2, 3, 4, 5]
- assert self._count_items(items) == 5
-
- def test_count_empty(self):
- assert self._count_items([]) == 0
-
- def test_count_by_field(self):
- items = [
- {"status": "active"},
- {"status": "inactive"},
- {"status": "active"},
- ]
- counts = self._count_by_field(items, "status")
- assert counts["active"] == 2
- assert counts["inactive"] == 1
-
- def test_count_if(self):
- items = [{"score": 80}, {"score": 45}, {"score": 90}]
- passing = self._count_if(items, lambda x: x["score"] >= 50)
- assert passing == 2
-
-
-class TestSumAggregation:
- """Tests for sum aggregation patterns."""
-
- def _sum_field(self, items, field):
- """Sum values of a field."""
- return sum(item.get(field, 0) for item in items)
-
- def _sum_by_group(self, items, group_field, value_field):
- """Sum values grouped by field."""
- sums = defaultdict(float)
- for item in items:
- key = item.get(group_field)
- sums[key] += item.get(value_field, 0)
- return dict(sums)
-
- def test_sum_field(self):
- items = [{"amount": 100}, {"amount": 200}, {"amount": 50}]
- assert self._sum_field(items, "amount") == 350
-
- def test_sum_empty(self):
- assert self._sum_field([], "amount") == 0
-
- def test_sum_by_group(self):
- items = [
- {"category": "A", "amount": 100},
- {"category": "B", "amount": 200},
- {"category": "A", "amount": 50},
- ]
- sums = self._sum_by_group(items, "category", "amount")
- assert sums["A"] == 150
- assert sums["B"] == 200
-
-
-class TestAverageAggregation:
- """Tests for average aggregation patterns."""
-
- def _average_field(self, items, field):
- """Calculate average of a field."""
- if not items:
- return 0
- values = [item.get(field, 0) for item in items]
- return sum(values) / len(values)
-
- def _weighted_average(self, items, value_field, weight_field):
- """Calculate weighted average."""
- total_value = 0
- total_weight = 0
- for item in items:
- value = item.get(value_field, 0)
- weight = item.get(weight_field, 1)
- total_value += value * weight
- total_weight += weight
- if total_weight == 0:
- return 0
- return total_value / total_weight
-
- def test_average(self):
- items = [{"score": 80}, {"score": 90}, {"score": 100}]
- assert self._average_field(items, "score") == 90
-
- def test_average_empty(self):
- assert self._average_field([], "score") == 0
-
- def test_weighted_average(self):
- items = [
- {"score": 80, "weight": 1},
- {"score": 100, "weight": 2},
- ]
- # (80*1 + 100*2) / (1+2) = 280/3 ≈ 93.33
- result = self._weighted_average(items, "score", "weight")
- assert abs(result - 93.33) < 0.01
-
-
-# --- Min/Max aggregation patterns ---
-
-
-class TestMinMaxAggregation:
- """Tests for min/max aggregation patterns."""
-
- def _min_field(self, items, field, default=None):
- """Get minimum value of a field."""
- if not items:
- return default
- return min(
- item.get(field) for item in items if item.get(field) is not None
- )
-
- def _max_field(self, items, field, default=None):
- """Get maximum value of a field."""
- if not items:
- return default
- return max(
- item.get(field) for item in items if item.get(field) is not None
- )
-
- def _find_min_item(self, items, field):
- """Find item with minimum field value."""
- if not items:
- return None
- return min(items, key=lambda x: x.get(field, float("inf")))
-
- def _find_max_item(self, items, field):
- """Find item with maximum field value."""
- if not items:
- return None
- return max(items, key=lambda x: x.get(field, float("-inf")))
-
- def test_min_field(self):
- items = [{"value": 50}, {"value": 25}, {"value": 75}]
- assert self._min_field(items, "value") == 25
-
- def test_max_field(self):
- items = [{"value": 50}, {"value": 25}, {"value": 75}]
- assert self._max_field(items, "value") == 75
-
- def test_min_empty(self):
- assert self._min_field([], "value", default=-1) == -1
-
- def test_find_min_item(self):
- items = [{"id": 1, "value": 50}, {"id": 2, "value": 25}]
- result = self._find_min_item(items, "value")
- assert result["id"] == 2
-
-
-# --- Grouping patterns ---
-
-
-class TestGroupingAggregation:
- """Tests for grouping aggregation patterns."""
-
- def _group_by(self, items, field):
- """Group items by field value."""
- groups = defaultdict(list)
- for item in items:
- key = item.get(field)
- groups[key].append(item)
- return dict(groups)
-
- def _group_by_multiple(self, items, fields):
- """Group by multiple fields."""
- groups = defaultdict(list)
- for item in items:
- key = tuple(item.get(f) for f in fields)
- groups[key].append(item)
- return dict(groups)
-
- def test_group_by_single(self):
- items = [
- {"category": "A", "value": 1},
- {"category": "B", "value": 2},
- {"category": "A", "value": 3},
- ]
- groups = self._group_by(items, "category")
- assert len(groups["A"]) == 2
- assert len(groups["B"]) == 1
-
- def test_group_by_multiple(self):
- items = [
- {"category": "A", "status": "active", "value": 1},
- {"category": "A", "status": "inactive", "value": 2},
- {"category": "A", "status": "active", "value": 3},
- ]
- groups = self._group_by_multiple(items, ["category", "status"])
- assert len(groups[("A", "active")]) == 2
-
-
-# --- Time-based aggregation patterns ---
-
-
-class TestTimeAggregation:
- """Tests for time-based aggregation patterns."""
-
- def _group_by_date(self, items, timestamp_field):
- """Group items by date."""
- groups = defaultdict(list)
- for item in items:
- ts = item.get(timestamp_field)
- if ts:
- date_key = ts.date() if hasattr(ts, "date") else ts
- groups[date_key].append(item)
- return dict(groups)
-
- def _group_by_hour(self, items, timestamp_field):
- """Group items by hour."""
- groups = defaultdict(list)
- for item in items:
- ts = item.get(timestamp_field)
- if ts and hasattr(ts, "hour"):
- hour_key = ts.replace(minute=0, second=0, microsecond=0)
- groups[hour_key].append(item)
- return dict(groups)
-
- def _count_by_period(self, items, timestamp_field, period_minutes=60):
- """Count items by time period."""
- counts = defaultdict(int)
- for item in items:
- ts = item.get(timestamp_field)
- if ts:
- period = ts.timestamp() // (period_minutes * 60)
- counts[period] += 1
- return dict(counts)
-
- def test_group_by_date(self):
- now = datetime.now(timezone.utc)
- yesterday = now - timedelta(days=1)
- items = [
- {"timestamp": now},
- {"timestamp": yesterday},
- {"timestamp": now},
- ]
- groups = self._group_by_date(items, "timestamp")
- assert len(groups) == 2
-
- def test_count_by_period(self):
- # Use a base time well inside a period boundary to avoid floating point edge cases
- base = datetime(2024, 1, 1, 12, 15, 0, tzinfo=timezone.utc)
- items = [
- {"timestamp": base},
- {"timestamp": base + timedelta(minutes=30)},
- {"timestamp": base + timedelta(minutes=90)},
- ]
- counts = self._count_by_period(items, "timestamp", period_minutes=60)
- # First two in same hour, third in next
- assert len(counts) == 2
-
-
-# --- Statistical aggregation patterns ---
-
-
-class TestStatisticalAggregation:
- """Tests for statistical aggregation patterns."""
-
- def _variance(self, values):
- """Calculate variance."""
- if len(values) < 2:
- return 0
- mean = sum(values) / len(values)
- return sum((x - mean) ** 2 for x in values) / len(values)
-
- def _std_dev(self, values):
- """Calculate standard deviation."""
- return math.sqrt(self._variance(values))
-
- def _percentile(self, values, p):
- """Calculate percentile."""
- if not values:
- return 0
- sorted_values = sorted(values)
- k = (len(sorted_values) - 1) * (p / 100)
- f = math.floor(k)
- c = math.ceil(k)
- if f == c:
- return sorted_values[int(k)]
- return sorted_values[f] * (c - k) + sorted_values[c] * (k - f)
-
- def _median(self, values):
- """Calculate median."""
- return self._percentile(values, 50)
-
- def test_variance(self):
- values = [2, 4, 4, 4, 5, 5, 7, 9]
- variance = self._variance(values)
- assert abs(variance - 4) < 0.01
-
- def test_std_dev(self):
- values = [2, 4, 4, 4, 5, 5, 7, 9]
- std = self._std_dev(values)
- assert abs(std - 2) < 0.01
-
- def test_median_odd(self):
- values = [1, 3, 5, 7, 9]
- assert self._median(values) == 5
-
- def test_median_even(self):
- values = [1, 2, 3, 4]
- assert self._median(values) == 2.5
-
- def test_percentile_90th(self):
- values = list(range(1, 101))
- p90 = self._percentile(values, 90)
- assert abs(p90 - 90.1) < 0.5
-
-
-# --- Running aggregation patterns ---
-
-
-class TestRunningAggregation:
- """Tests for running/cumulative aggregation patterns."""
-
- def _running_sum(self, values):
- """Calculate running sum."""
- result = []
- total = 0
- for v in values:
- total += v
- result.append(total)
- return result
-
- def _running_average(self, values):
- """Calculate running average."""
- result = []
- total = 0
- for i, v in enumerate(values):
- total += v
- result.append(total / (i + 1))
- return result
-
- def _exponential_moving_average(self, values, alpha=0.3):
- """Calculate exponential moving average."""
- if not values:
- return []
- result = [values[0]]
- for v in values[1:]:
- ema = alpha * v + (1 - alpha) * result[-1]
- result.append(ema)
- return result
-
- def test_running_sum(self):
- values = [1, 2, 3, 4, 5]
- result = self._running_sum(values)
- assert result == [1, 3, 6, 10, 15]
-
- def test_running_average(self):
- values = [10, 20, 30]
- result = self._running_average(values)
- assert result[0] == 10
- assert result[1] == 15
- assert result[2] == 20
-
- def test_exponential_moving_average(self):
- values = [10, 10, 10, 20, 20, 20]
- result = self._exponential_moving_average(values, alpha=0.5)
- # Values should gradually approach 20
- assert result[0] == 10
- assert result[-1] > 15
-
-
-# --- Distinct/unique aggregation patterns ---
-
-
-class TestDistinctAggregation:
- """Tests for distinct value aggregation patterns."""
-
- def _count_distinct(self, items, field):
- """Count distinct values of a field."""
- return len(
- set(
- item.get(field) for item in items if item.get(field) is not None
- )
- )
-
- def _get_distinct_values(self, items, field):
- """Get distinct values of a field."""
- return list(
- set(
- item.get(field) for item in items if item.get(field) is not None
- )
- )
-
- def _count_distinct_combinations(self, items, fields):
- """Count distinct combinations of fields."""
- combos = set()
- for item in items:
- combo = tuple(item.get(f) for f in fields)
- if None not in combo:
- combos.add(combo)
- return len(combos)
-
- def test_count_distinct(self):
- items = [{"user_id": 1}, {"user_id": 2}, {"user_id": 1}]
- assert self._count_distinct(items, "user_id") == 2
-
- def test_get_distinct_values(self):
- items = [{"status": "a"}, {"status": "b"}, {"status": "a"}]
- distinct = self._get_distinct_values(items, "status")
- assert set(distinct) == {"a", "b"}
-
- def test_count_distinct_combinations(self):
- items = [
- {"a": 1, "b": "x"},
- {"a": 1, "b": "y"},
- {"a": 1, "b": "x"}, # duplicate
- ]
- assert self._count_distinct_combinations(items, ["a", "b"]) == 2
-
-
-# --- Bucket aggregation patterns ---
-
-
-class TestBucketAggregation:
- """Tests for bucket/histogram aggregation patterns."""
-
- def _bucket_by_range(self, items, field, ranges):
- """Bucket items by value ranges."""
- buckets = {r: [] for r in ranges}
- for item in items:
- value = item.get(field)
- if value is None:
- continue
- for r in ranges:
- if r[0] <= value < r[1]:
- buckets[r].append(item)
- break
- return buckets
-
- def _histogram(self, values, num_buckets=10):
- """Create histogram buckets."""
- if not values:
- return {}
- min_val = min(values)
- max_val = max(values)
- if min_val == max_val:
- return {(min_val, max_val + 1): len(values)}
- bucket_size = (max_val - min_val) / num_buckets
- buckets = defaultdict(int)
- for v in values:
- bucket_idx = int((v - min_val) / bucket_size)
- bucket_idx = min(bucket_idx, num_buckets - 1)
- bucket_start = min_val + bucket_idx * bucket_size
- bucket_end = bucket_start + bucket_size
- buckets[(bucket_start, bucket_end)] += 1
- return dict(buckets)
-
- def test_bucket_by_range(self):
- items = [{"score": 25}, {"score": 55}, {"score": 85}, {"score": 95}]
- ranges = [(0, 50), (50, 75), (75, 100)]
- buckets = self._bucket_by_range(items, "score", ranges)
- assert len(buckets[(0, 50)]) == 1
- assert len(buckets[(50, 75)]) == 1
- assert len(buckets[(75, 100)]) == 2
-
- def test_histogram(self):
- values = list(range(100))
- buckets = self._histogram(values, num_buckets=10)
- # Each bucket should have ~10 values
- assert len(buckets) == 10
-
-
-# --- Top-N aggregation patterns ---
-
-
-class TestTopNAggregation:
- """Tests for top-N aggregation patterns."""
-
- def _top_n(self, items, field, n, ascending=False):
- """Get top N items by field."""
- sorted_items = sorted(
- items,
- key=lambda x: x.get(
- field, float("-inf") if not ascending else float("inf")
- ),
- reverse=not ascending,
- )
- return sorted_items[:n]
-
- def _top_n_per_group(self, items, group_field, value_field, n):
- """Get top N items per group."""
- groups = defaultdict(list)
- for item in items:
- groups[item.get(group_field)].append(item)
- result = {}
- for group_key, group_items in groups.items():
- sorted_items = sorted(
- group_items,
- key=lambda x: x.get(value_field, 0),
- reverse=True,
- )
- result[group_key] = sorted_items[:n]
- return result
-
- def test_top_n(self):
- items = [
- {"name": "a", "score": 80},
- {"name": "b", "score": 95},
- {"name": "c", "score": 70},
- ]
- top = self._top_n(items, "score", 2)
- assert top[0]["name"] == "b"
- assert len(top) == 2
-
- def test_bottom_n(self):
- items = [
- {"name": "a", "score": 80},
- {"name": "b", "score": 95},
- {"name": "c", "score": 70},
- ]
- bottom = self._top_n(items, "score", 2, ascending=True)
- assert bottom[0]["name"] == "c"
-
- def test_top_n_per_group(self):
- items = [
- {"group": "A", "score": 80},
- {"group": "A", "score": 90},
- {"group": "B", "score": 85},
- {"group": "B", "score": 75},
- ]
- result = self._top_n_per_group(items, "group", "score", 1)
- assert result["A"][0]["score"] == 90
- assert result["B"][0]["score"] == 85
-
-
-# --- Conditional aggregation patterns ---
-
-
-class TestConditionalAggregation:
- """Tests for conditional aggregation patterns."""
-
- def _sum_if(self, items, field, predicate):
- """Sum field values where predicate is true."""
- return sum(item.get(field, 0) for item in items if predicate(item))
-
- def _avg_if(self, items, field, predicate):
- """Average field values where predicate is true."""
- matching = [
- item.get(field)
- for item in items
- if predicate(item) and item.get(field) is not None
- ]
- if not matching:
- return 0
- return sum(matching) / len(matching)
-
- def test_sum_if(self):
- items = [
- {"status": "active", "amount": 100},
- {"status": "inactive", "amount": 50},
- {"status": "active", "amount": 75},
- ]
- total = self._sum_if(
- items, "amount", lambda x: x.get("status") == "active"
- )
- assert total == 175
-
- def test_avg_if(self):
- items = [
- {"type": "A", "score": 80},
- {"type": "B", "score": 60},
- {"type": "A", "score": 100},
- ]
- avg = self._avg_if(items, "score", lambda x: x.get("type") == "A")
- assert avg == 90
-
-
-# --- Pivot/cross-tab patterns ---
-
-
-class TestPivotAggregation:
- """Tests for pivot/cross-tab aggregation patterns."""
-
- def _pivot_count(self, items, row_field, col_field):
- """Create pivot table with counts."""
- pivot = defaultdict(lambda: defaultdict(int))
- for item in items:
- row = item.get(row_field)
- col = item.get(col_field)
- pivot[row][col] += 1
- return {k: dict(v) for k, v in pivot.items()}
-
- def _pivot_sum(self, items, row_field, col_field, value_field):
- """Create pivot table with sums."""
- pivot = defaultdict(lambda: defaultdict(float))
- for item in items:
- row = item.get(row_field)
- col = item.get(col_field)
- pivot[row][col] += item.get(value_field, 0)
- return {k: dict(v) for k, v in pivot.items()}
-
- def test_pivot_count(self):
- items = [
- {"region": "East", "status": "active"},
- {"region": "East", "status": "inactive"},
- {"region": "West", "status": "active"},
- {"region": "East", "status": "active"},
- ]
- pivot = self._pivot_count(items, "region", "status")
- assert pivot["East"]["active"] == 2
- assert pivot["East"]["inactive"] == 1
- assert pivot["West"]["active"] == 1
-
- def test_pivot_sum(self):
- items = [
- {"region": "East", "category": "A", "sales": 100},
- {"region": "East", "category": "B", "sales": 200},
- {"region": "East", "category": "A", "sales": 50},
- ]
- pivot = self._pivot_sum(items, "region", "category", "sales")
- assert pivot["East"]["A"] == 150
- assert pivot["East"]["B"] == 200
diff --git a/tests/news/test_data_serialization_patterns_behavior.py b/tests/news/test_data_serialization_patterns_behavior.py
deleted file mode 100644
index f5d375e19c..0000000000
--- a/tests/news/test_data_serialization_patterns_behavior.py
+++ /dev/null
@@ -1,885 +0,0 @@
-"""
-Behavioral tests for data serialization patterns.
-
-These tests verify the logic of data serialization patterns like JSON encoding,
-data transformation, schema conversion, and data migration
-without making actual external calls.
-"""
-
-import base64
-import json
-from dataclasses import dataclass
-from datetime import date, datetime, time
-from decimal import Decimal
-from enum import Enum
-from uuid import UUID
-
-
-class TestJSONSerialization:
- """Tests for JSON serialization patterns."""
-
- def test_serialize_basic_types(self):
- """Test serializing basic Python types."""
-
- def serialize(obj):
- return json.dumps(obj)
-
- assert serialize("hello") == '"hello"'
- assert serialize(123) == "123"
- assert serialize(3.14) == "3.14"
- assert serialize(True) == "true"
- assert serialize(None) == "null"
- assert serialize([1, 2, 3]) == "[1, 2, 3]"
- assert serialize({"a": 1}) == '{"a": 1}'
-
- def test_serialize_datetime(self):
- """Test serializing datetime objects."""
-
- def default_encoder(obj):
- if isinstance(obj, datetime):
- return obj.isoformat()
- if isinstance(obj, date):
- return obj.isoformat()
- if isinstance(obj, time):
- return obj.isoformat()
- raise TypeError(
- f"Object of type {type(obj)} is not JSON serializable"
- )
-
- dt = datetime(2024, 1, 15, 12, 30, 45)
- result = json.dumps({"timestamp": dt}, default=default_encoder)
- assert '"2024-01-15T12:30:45"' in result
-
- d = date(2024, 1, 15)
- result = json.dumps({"date": d}, default=default_encoder)
- assert '"2024-01-15"' in result
-
- def test_serialize_uuid(self):
- """Test serializing UUID objects."""
-
- def default_encoder(obj):
- if isinstance(obj, UUID):
- return str(obj)
- raise TypeError(
- f"Object of type {type(obj)} is not JSON serializable"
- )
-
- uid = UUID("12345678-1234-5678-1234-567812345678")
- result = json.dumps({"id": uid}, default=default_encoder)
- assert '"12345678-1234-5678-1234-567812345678"' in result
-
- def test_serialize_decimal(self):
- """Test serializing Decimal objects."""
-
- def default_encoder(obj):
- if isinstance(obj, Decimal):
- return float(obj)
- raise TypeError(
- f"Object of type {type(obj)} is not JSON serializable"
- )
-
- d = Decimal("10.25")
- result = json.dumps({"price": d}, default=default_encoder)
- parsed = json.loads(result)
- assert parsed["price"] == 10.25
-
- def test_serialize_enum(self):
- """Test serializing Enum objects."""
-
- class Status(Enum):
- ACTIVE = "active"
- INACTIVE = "inactive"
-
- def default_encoder(obj):
- if isinstance(obj, Enum):
- return obj.value
- raise TypeError(
- f"Object of type {type(obj)} is not JSON serializable"
- )
-
- result = json.dumps({"status": Status.ACTIVE}, default=default_encoder)
- assert '"active"' in result
-
-
-class TestJSONDeserialization:
- """Tests for JSON deserialization patterns."""
-
- def test_deserialize_basic_types(self):
- """Test deserializing basic JSON types."""
-
- assert json.loads('"hello"') == "hello"
- assert json.loads("123") == 123
- assert json.loads("3.14") == 3.14
- assert json.loads("true") is True
- assert json.loads("null") is None
- assert json.loads("[1, 2, 3]") == [1, 2, 3]
- assert json.loads('{"a": 1}') == {"a": 1}
-
- def test_deserialize_datetime(self):
- """Test deserializing datetime strings."""
-
- def parse_datetime(value):
- if isinstance(value, str):
- try:
- return datetime.fromisoformat(value)
- except ValueError:
- pass
- return value
-
- def object_hook(obj):
- for key, value in obj.items():
- obj[key] = parse_datetime(value)
- return obj
-
- result = json.loads(
- '{"timestamp": "2024-01-15T12:30:45"}', object_hook=object_hook
- )
- assert isinstance(result["timestamp"], datetime)
- assert result["timestamp"].year == 2024
-
- def test_deserialize_with_type_hints(self):
- """Test deserializing with type conversion."""
-
- def convert_value(value, target_type):
- if target_type is int:
- return int(value)
- if target_type is float:
- return float(value)
- if target_type is bool:
- if isinstance(value, str):
- return value.lower() in ("true", "1", "yes")
- return bool(value)
- if target_type is datetime:
- return datetime.fromisoformat(value)
- return value
-
- assert convert_value("123", int) == 123
- assert convert_value("3.14", float) == 3.14
- assert convert_value("true", bool) is True
- assert convert_value("2024-01-01", datetime) == datetime(2024, 1, 1)
-
- def test_handle_missing_fields(self):
- """Test handling missing fields with defaults."""
-
- def deserialize_with_defaults(data, defaults):
- result = defaults.copy()
- result.update(data)
- return result
-
- data = {"name": "John"}
- defaults = {"name": "", "age": 0, "active": True}
- result = deserialize_with_defaults(data, defaults)
- assert result["name"] == "John"
- assert result["age"] == 0
- assert result["active"] is True
-
- def test_handle_extra_fields(self):
- """Test handling extra fields."""
-
- def deserialize_strict(data, allowed_fields):
- return {k: v for k, v in data.items() if k in allowed_fields}
-
- data = {"name": "John", "age": 30, "extra": "ignored"}
- allowed = {"name", "age"}
- result = deserialize_strict(data, allowed)
- assert "extra" not in result
- assert result == {"name": "John", "age": 30}
-
-
-class TestBinarySerialization:
- """Tests for binary serialization patterns."""
-
- def test_base64_encode(self):
- """Test base64 encoding."""
- data = b"Hello, World!"
- encoded = base64.b64encode(data).decode()
- assert encoded == "SGVsbG8sIFdvcmxkIQ=="
-
- def test_base64_decode(self):
- """Test base64 decoding."""
- encoded = "SGVsbG8sIFdvcmxkIQ=="
- decoded = base64.b64decode(encoded)
- assert decoded == b"Hello, World!"
-
- def test_base64_url_safe(self):
- """Test URL-safe base64 encoding."""
- data = b"\xff\xfe\xfd" # Binary data with special chars
- encoded = base64.urlsafe_b64encode(data).decode()
- # URL-safe should not contain + or /
- assert "+" not in encoded
- assert "/" not in encoded
-
- def test_hex_encode(self):
- """Test hex encoding."""
- data = b"\x00\x01\x02\xff"
- encoded = data.hex()
- assert encoded == "000102ff"
-
- def test_hex_decode(self):
- """Test hex decoding."""
- encoded = "000102ff"
- decoded = bytes.fromhex(encoded)
- assert decoded == b"\x00\x01\x02\xff"
-
-
-class TestDataTransformation:
- """Tests for data transformation patterns."""
-
- def test_snake_to_camel_case(self):
- """Test converting snake_case to camelCase."""
-
- def to_camel_case(snake_str):
- components = snake_str.split("_")
- return components[0] + "".join(x.title() for x in components[1:])
-
- assert to_camel_case("user_name") == "userName"
- assert to_camel_case("first_name_last") == "firstNameLast"
- assert to_camel_case("simple") == "simple"
-
- def test_camel_to_snake_case(self):
- """Test converting camelCase to snake_case."""
-
- def to_snake_case(camel_str):
- result = []
- for char in camel_str:
- if char.isupper():
- result.append("_")
- result.append(char.lower())
- else:
- result.append(char)
- return "".join(result).lstrip("_")
-
- assert to_snake_case("userName") == "user_name"
- assert to_snake_case("firstName") == "first_name"
- assert to_snake_case("simple") == "simple"
-
- def test_convert_dict_keys(self):
- """Test converting all dict keys."""
-
- def convert_keys(obj, converter):
- if isinstance(obj, dict):
- return {
- converter(k): convert_keys(v, converter)
- for k, v in obj.items()
- }
- if isinstance(obj, list):
- return [convert_keys(item, converter) for item in obj]
- return obj
-
- def to_upper(key):
- return key.upper()
-
- data = {"name": "John", "address": {"city": "NYC"}}
- result = convert_keys(data, to_upper)
- assert result == {"NAME": "John", "ADDRESS": {"CITY": "NYC"}}
-
- def test_flatten_dict(self):
- """Test flattening nested dict."""
-
- def flatten_dict(d, parent_key="", sep="."):
- items = []
- for k, v in d.items():
- new_key = f"{parent_key}{sep}{k}" if parent_key else k
- if isinstance(v, dict):
- items.extend(flatten_dict(v, new_key, sep).items())
- else:
- items.append((new_key, v))
- return dict(items)
-
- data = {"user": {"name": "John", "address": {"city": "NYC"}}}
- result = flatten_dict(data)
- assert result == {"user.name": "John", "user.address.city": "NYC"}
-
- def test_unflatten_dict(self):
- """Test unflattening a flat dict."""
-
- def unflatten_dict(d, sep="."):
- result = {}
- for key, value in d.items():
- parts = key.split(sep)
- current = result
- for part in parts[:-1]:
- if part not in current:
- current[part] = {}
- current = current[part]
- current[parts[-1]] = value
- return result
-
- data = {"user.name": "John", "user.address.city": "NYC"}
- result = unflatten_dict(data)
- assert result == {"user": {"name": "John", "address": {"city": "NYC"}}}
-
-
-class TestSchemaConversion:
- """Tests for schema conversion patterns."""
-
- def test_dict_to_dataclass(self):
- """Test converting dict to dataclass."""
-
- @dataclass
- class User:
- name: str
- age: int
- active: bool = True
-
- def dict_to_dataclass(cls, data):
- field_names = {f.name for f in cls.__dataclass_fields__.values()}
- filtered = {k: v for k, v in data.items() if k in field_names}
- return cls(**filtered)
-
- data = {"name": "John", "age": 30, "extra": "ignored"}
- user = dict_to_dataclass(User, data)
- assert user.name == "John"
- assert user.age == 30
- assert user.active is True
-
- def test_dataclass_to_dict(self):
- """Test converting dataclass to dict."""
- from dataclasses import asdict
-
- @dataclass
- class User:
- name: str
- age: int
- active: bool = True
-
- user = User(name="John", age=30)
- result = asdict(user)
- assert result == {"name": "John", "age": 30, "active": True}
-
- def test_api_response_to_model(self):
- """Test converting API response to internal model."""
-
- def convert_api_user(api_data):
- return {
- "id": api_data.get("userId"),
- "name": api_data.get("fullName"),
- "email": api_data.get("emailAddress"),
- "created_at": api_data.get("createdDate"),
- }
-
- api_response = {
- "userId": "123",
- "fullName": "John Doe",
- "emailAddress": "[email protected]",
- "createdDate": "2024-01-01",
- }
- model = convert_api_user(api_response)
- assert model["id"] == "123"
- assert model["name"] == "John Doe"
-
- def test_model_to_api_request(self):
- """Test converting internal model to API request."""
-
- def convert_to_api(model):
- return {
- "userId": model.get("id"),
- "fullName": model.get("name"),
- "emailAddress": model.get("email"),
- }
-
- model = {"id": "123", "name": "John Doe", "email": "[email protected]"}
- api_request = convert_to_api(model)
- assert api_request["userId"] == "123"
- assert api_request["fullName"] == "John Doe"
-
- def test_version_migration(self):
- """Test migrating data between schema versions."""
-
- def migrate_v1_to_v2(v1_data):
- # V1 had fullName, V2 has firstName and lastName
- full_name = v1_data.get("fullName", "")
- parts = full_name.split(" ", 1)
- return {
- "firstName": parts[0] if parts else "",
- "lastName": parts[1] if len(parts) > 1 else "",
- "email": v1_data.get("email"),
- "schemaVersion": 2,
- }
-
- v1 = {
- "fullName": "John Doe",
- "email": "[email protected]",
- "schemaVersion": 1,
- }
- v2 = migrate_v1_to_v2(v1)
- assert v2["firstName"] == "John"
- assert v2["lastName"] == "Doe"
- assert v2["schemaVersion"] == 2
-
-
-class TestCollectionSerialization:
- """Tests for collection serialization patterns."""
-
- def test_serialize_list(self):
- """Test serializing lists."""
-
- def serialize_list(items, serializer):
- return [serializer(item) for item in items]
-
- def item_serializer(item):
- return {"id": item["id"], "name": item["name"].upper()}
-
- items = [{"id": 1, "name": "apple"}, {"id": 2, "name": "banana"}]
- result = serialize_list(items, item_serializer)
- assert result[0]["name"] == "APPLE"
- assert result[1]["name"] == "BANANA"
-
- def test_serialize_dict_values(self):
- """Test serializing dict values."""
-
- def serialize_values(data, serializer):
- return {k: serializer(v) for k, v in data.items()}
-
- data = {"a": 1, "b": 2, "c": 3}
- result = serialize_values(data, lambda x: x * 2)
- assert result == {"a": 2, "b": 4, "c": 6}
-
- def test_paginated_serialization(self):
- """Test serializing paginated results."""
-
- def serialize_paginated(items, page, page_size, total, serializer):
- return {
- "data": [serializer(item) for item in items],
- "pagination": {
- "page": page,
- "page_size": page_size,
- "total": total,
- "total_pages": (total + page_size - 1) // page_size,
- },
- }
-
- items = [{"id": 1}, {"id": 2}]
- result = serialize_paginated(
- items, page=1, page_size=10, total=25, serializer=lambda x: x
- )
- assert result["pagination"]["total_pages"] == 3
- assert len(result["data"]) == 2
-
- def test_serialize_with_includes(self):
- """Test serializing with related data."""
-
- def serialize_with_includes(item, includes):
- result = {"id": item["id"], "name": item["name"]}
- if "address" in includes and "address" in item:
- result["address"] = item["address"]
- if "orders" in includes and "orders" in item:
- result["orders"] = item["orders"]
- return result
-
- item = {
- "id": 1,
- "name": "John",
- "address": {"city": "NYC"},
- "orders": [{"id": 100}],
- }
- result = serialize_with_includes(item, includes=["address"])
- assert "address" in result
- assert "orders" not in result
-
- def test_sparse_serialization(self):
- """Test sparse fieldsets serialization."""
-
- def serialize_sparse(item, fields):
- if not fields:
- return item
- return {k: v for k, v in item.items() if k in fields}
-
- item = {"id": 1, "name": "John", "email": "[email protected]", "age": 30}
- result = serialize_sparse(item, fields=["id", "name"])
- assert result == {"id": 1, "name": "John"}
-
-
-class TestCustomEncoders:
- """Tests for custom encoder patterns."""
-
- def test_custom_json_encoder_class(self):
- """Test custom JSON encoder class."""
-
- class CustomEncoder(json.JSONEncoder):
- def default(self, obj):
- if isinstance(obj, datetime):
- return {"__datetime__": True, "value": obj.isoformat()}
- if isinstance(obj, Decimal):
- return {"__decimal__": True, "value": str(obj)}
- return super().default(obj)
-
- data = {"dt": datetime(2024, 1, 1), "price": Decimal("10.50")}
- result = json.dumps(data, cls=CustomEncoder)
- parsed = json.loads(result)
- assert parsed["dt"]["__datetime__"] is True
- assert parsed["price"]["__decimal__"] is True
-
- def test_custom_decoder_hook(self):
- """Test custom JSON decoder hook."""
-
- def custom_decoder(obj):
- if "__datetime__" in obj:
- return datetime.fromisoformat(obj["value"])
- if "__decimal__" in obj:
- return Decimal(obj["value"])
- return obj
-
- data = '{"dt": {"__datetime__": true, "value": "2024-01-01T00:00:00"}}'
- result = json.loads(data, object_hook=custom_decoder)
- assert isinstance(result["dt"], datetime)
-
- def test_serialize_with_context(self):
- """Test serialization with context."""
-
- def serialize_user(user, context):
- result = {"id": user["id"], "name": user["name"]}
- if context.get("include_email"):
- result["email"] = user["email"]
- if context.get("include_private"):
- result["ssn"] = user.get("ssn")
- return result
-
- user = {
- "id": 1,
- "name": "John",
- "email": "[email protected]",
- "ssn": "123-45-6789",
- }
-
- public = serialize_user(user, {"include_email": True})
- assert "email" in public
- assert "ssn" not in public
-
- private = serialize_user(
- user, {"include_email": True, "include_private": True}
- )
- assert "ssn" in private
-
- def test_versioned_serialization(self):
- """Test versioned serialization."""
-
- def serialize_v1(user):
- return {
- "version": 1,
- "fullName": user["name"],
- "emailAddress": user["email"],
- }
-
- def serialize_v2(user):
- names = user["name"].split(" ", 1)
- return {
- "version": 2,
- "firstName": names[0],
- "lastName": names[1] if len(names) > 1 else "",
- "email": user["email"],
- }
-
- def serialize(user, version=2):
- if version == 1:
- return serialize_v1(user)
- return serialize_v2(user)
-
- user = {"name": "John Doe", "email": "[email protected]"}
- v1 = serialize(user, version=1)
- v2 = serialize(user, version=2)
- assert v1["fullName"] == "John Doe"
- assert v2["firstName"] == "John"
-
- def test_null_handling(self):
- """Test null value handling strategies."""
-
- def serialize_omit_nulls(data):
- return {k: v for k, v in data.items() if v is not None}
-
- def serialize_explicit_nulls(data, nullable_fields):
- result = {}
- for key, value in data.items():
- if value is not None:
- result[key] = value
- elif key in nullable_fields:
- result[key] = None
- return result
-
- data = {"name": "John", "age": None, "email": None}
-
- omitted = serialize_omit_nulls(data)
- assert "age" not in omitted
-
- explicit = serialize_explicit_nulls(data, nullable_fields={"age"})
- assert "age" in explicit
- assert explicit["age"] is None
- assert "email" not in explicit
-
-
-class TestDataValidation:
- """Tests for data validation during serialization."""
-
- def test_validate_required_fields(self):
- """Test validating required fields."""
-
- def validate_required(data, required):
- missing = [f for f in required if f not in data or data[f] is None]
- if missing:
- return {
- "valid": False,
- "errors": [f"Missing: {f}" for f in missing],
- }
- return {"valid": True, "errors": []}
-
- result = validate_required({"name": "John"}, ["name", "email"])
- assert result["valid"] is False
- assert "Missing: email" in result["errors"]
-
- def test_validate_types(self):
- """Test validating field types."""
-
- def validate_types(data, type_spec):
- errors = []
- for field, expected_type in type_spec.items():
- if field in data and data[field] is not None:
- if not isinstance(data[field], expected_type):
- errors.append(
- f"{field}: expected {expected_type.__name__}"
- )
- return {"valid": len(errors) == 0, "errors": errors}
-
- result = validate_types(
- {"name": "John", "age": "thirty"}, {"name": str, "age": int}
- )
- assert result["valid"] is False
- assert "age: expected int" in result["errors"]
-
- def test_coerce_types(self):
- """Test coercing types during deserialization."""
-
- def coerce_types(data, type_spec):
- result = {}
- for field, value in data.items():
- if field in type_spec and value is not None:
- try:
- result[field] = type_spec[field](value)
- except (ValueError, TypeError):
- result[field] = value
- else:
- result[field] = value
- return result
-
- data = {"name": "John", "age": "30", "active": "true"}
- type_spec = {"age": int, "active": lambda x: x.lower() == "true"}
- result = coerce_types(data, type_spec)
- assert result["age"] == 30
- assert result["active"] is True
-
- def test_validate_format(self):
- """Test validating field formats."""
- import re
-
- def validate_format(value, pattern):
- if re.match(pattern, value):
- return True
- return False
-
- email_pattern = r"^[\w.-]+@[\w.-]+\.\w+$"
- assert validate_format("[email protected]", email_pattern) is True
- assert validate_format("invalid-email", email_pattern) is False
-
- def test_sanitize_during_serialization(self):
- """Test sanitizing data during serialization."""
-
- def sanitize_string(value, max_length=100):
- if not isinstance(value, str):
- return value
- value = value.strip()
- if len(value) > max_length:
- value = value[:max_length]
- return value
-
- def serialize_with_sanitization(data, string_fields):
- result = {}
- for key, value in data.items():
- if key in string_fields:
- result[key] = sanitize_string(value)
- else:
- result[key] = value
- return result
-
- data = {"name": " John ", "bio": "x" * 200}
- result = serialize_with_sanitization(
- data, string_fields=["name", "bio"]
- )
- assert result["name"] == "John"
- assert len(result["bio"]) == 100
-
-
-class TestStreamingSerialization:
- """Tests for streaming serialization patterns."""
-
- def test_chunk_iterator(self):
- """Test iterating over chunks."""
-
- def chunk_iterator(items, chunk_size):
- for i in range(0, len(items), chunk_size):
- yield items[i : i + chunk_size]
-
- items = list(range(10))
- chunks = list(chunk_iterator(items, 3))
- assert len(chunks) == 4
- assert chunks[0] == [0, 1, 2]
- assert chunks[-1] == [9]
-
- def test_serialize_large_list(self):
- """Test serializing large list in chunks."""
-
- def serialize_in_chunks(items, chunk_size, serializer):
- for i in range(0, len(items), chunk_size):
- chunk = items[i : i + chunk_size]
- yield [serializer(item) for item in chunk]
-
- items = [{"id": i} for i in range(100)]
- chunks = list(serialize_in_chunks(items, 30, lambda x: x["id"]))
- assert len(chunks) == 4
- assert chunks[0] == list(range(30))
-
- def test_json_lines_format(self):
- """Test JSON Lines format."""
-
- def to_json_lines(items):
- return "\n".join(json.dumps(item) for item in items)
-
- def from_json_lines(text):
- return [
- json.loads(line) for line in text.strip().split("\n") if line
- ]
-
- items = [{"id": 1}, {"id": 2}, {"id": 3}]
- jsonl = to_json_lines(items)
- parsed = from_json_lines(jsonl)
- assert parsed == items
-
- def test_incremental_builder(self):
- """Test incremental object builder."""
-
- class ObjectBuilder:
- def __init__(self):
- self.data = {}
-
- def set(self, key, value):
- self.data[key] = value
- return self
-
- def build(self):
- return self.data.copy()
-
- builder = ObjectBuilder()
- result = builder.set("name", "John").set("age", 30).build()
- assert result == {"name": "John", "age": 30}
-
- def test_lazy_serialization(self):
- """Test lazy serialization pattern."""
-
- class LazySerializer:
- def __init__(self, data, serializer):
- self._data = data
- self._serializer = serializer
- self._cached = None
-
- def serialize(self):
- if self._cached is None:
- self._cached = self._serializer(self._data)
- return self._cached
-
- data = {"name": "John"}
- serializer = LazySerializer(data, json.dumps)
- # First call computes
- result1 = serializer.serialize()
- # Second call uses cache
- result2 = serializer.serialize()
- assert result1 == result2 == '{"name": "John"}'
-
-
-class TestErrorHandling:
- """Tests for serialization error handling."""
-
- def test_handle_circular_reference(self):
- """Test handling circular references."""
-
- def safe_serialize(obj, seen=None):
- if seen is None:
- seen = set()
- obj_id = id(obj)
- if obj_id in seen:
- return "[Circular]"
- if isinstance(obj, dict):
- seen.add(obj_id)
- return {k: safe_serialize(v, seen) for k, v in obj.items()}
- if isinstance(obj, list):
- seen.add(obj_id)
- return [safe_serialize(item, seen) for item in obj]
- return obj
-
- # Create circular reference
- data = {"name": "John"}
- data["self"] = data
- result = safe_serialize(data)
- assert result["self"] == "[Circular]"
-
- def test_handle_encoding_error(self):
- """Test handling encoding errors."""
-
- def safe_encode(obj, default_value="[Unserializable]"):
- try:
- return json.dumps(obj)
- except (TypeError, ValueError):
- return default_value
-
- assert safe_encode({"name": "John"}) == '{"name": "John"}'
- assert safe_encode({"fn": lambda x: x}) == "[Unserializable]"
-
- def test_partial_serialization(self):
- """Test partial serialization on error."""
-
- def partial_serialize(data, serializers):
- result = {}
- errors = []
- for key, value in data.items():
- try:
- if key in serializers:
- result[key] = serializers[key](value)
- else:
- result[key] = value
- except Exception as e:
- errors.append({"field": key, "error": str(e)})
- result[key] = None
- return {"data": result, "errors": errors}
-
- data = {"name": "John", "age": "not-a-number"}
- serializers = {"age": int}
- result = partial_serialize(data, serializers)
- assert result["data"]["name"] == "John"
- assert result["data"]["age"] is None
- assert len(result["errors"]) == 1
-
- def test_validation_error_collection(self):
- """Test collecting multiple validation errors."""
-
- def validate_all(data, validators):
- errors = []
- for field, validator in validators.items():
- if field in data:
- error = validator(data[field])
- if error:
- errors.append({"field": field, "error": error})
- return errors
-
- def validate_age(age):
- if not isinstance(age, int):
- return "must be an integer"
- if age < 0:
- return "must be positive"
- return None
-
- def validate_name(name):
- if not name:
- return "cannot be empty"
- return None
-
- data = {"name": "", "age": -5}
- validators = {"name": validate_name, "age": validate_age}
- errors = validate_all(data, validators)
- assert len(errors) == 2
diff --git a/tests/news/test_data_structures_patterns_behavior.py b/tests/news/test_data_structures_patterns_behavior.py
deleted file mode 100644
index 18aa8d12fc..0000000000
--- a/tests/news/test_data_structures_patterns_behavior.py
+++ /dev/null
@@ -1,1008 +0,0 @@
-"""
-Behavioral tests for data structure patterns.
-
-These tests verify the logic of data structure patterns like trees,
-graphs, linked lists, and specialized collections without making actual
-external calls.
-"""
-
-from dataclasses import dataclass
-from typing import Any
-
-
-class TestTreeStructures:
- """Tests for tree data structure patterns."""
-
- def test_binary_tree_traversal_inorder(self):
- """Test in-order tree traversal."""
-
- @dataclass
- class TreeNode:
- value: Any
- left: "TreeNode" = None
- right: "TreeNode" = None
-
- def inorder(node, result=None):
- if result is None:
- result = []
- if node:
- inorder(node.left, result)
- result.append(node.value)
- inorder(node.right, result)
- return result
-
- # 2
- # / \
- # 1 3
- root = TreeNode(2, TreeNode(1), TreeNode(3))
- assert inorder(root) == [1, 2, 3]
-
- def test_binary_tree_traversal_preorder(self):
- """Test pre-order tree traversal."""
-
- @dataclass
- class TreeNode:
- value: Any
- left: "TreeNode" = None
- right: "TreeNode" = None
-
- def preorder(node, result=None):
- if result is None:
- result = []
- if node:
- result.append(node.value)
- preorder(node.left, result)
- preorder(node.right, result)
- return result
-
- root = TreeNode(2, TreeNode(1), TreeNode(3))
- assert preorder(root) == [2, 1, 3]
-
- def test_binary_tree_traversal_postorder(self):
- """Test post-order tree traversal."""
-
- @dataclass
- class TreeNode:
- value: Any
- left: "TreeNode" = None
- right: "TreeNode" = None
-
- def postorder(node, result=None):
- if result is None:
- result = []
- if node:
- postorder(node.left, result)
- postorder(node.right, result)
- result.append(node.value)
- return result
-
- root = TreeNode(2, TreeNode(1), TreeNode(3))
- assert postorder(root) == [1, 3, 2]
-
- def test_tree_height(self):
- """Test calculating tree height."""
-
- @dataclass
- class TreeNode:
- value: Any
- left: "TreeNode" = None
- right: "TreeNode" = None
-
- def height(node):
- if node is None:
- return 0
- return 1 + max(height(node.left), height(node.right))
-
- # Single node
- assert height(TreeNode(1)) == 1
-
- # Three levels
- root = TreeNode(1, TreeNode(2, TreeNode(3)), TreeNode(4))
- assert height(root) == 3
-
- def test_find_in_tree(self):
- """Test finding value in tree."""
-
- @dataclass
- class TreeNode:
- value: Any
- left: "TreeNode" = None
- right: "TreeNode" = None
-
- def find(node, value):
- if node is None:
- return False
- if node.value == value:
- return True
- return find(node.left, value) or find(node.right, value)
-
- root = TreeNode(1, TreeNode(2), TreeNode(3))
- assert find(root, 2) is True
- assert find(root, 5) is False
-
-
-class TestTrieStructure:
- """Tests for Trie (prefix tree) patterns."""
-
- def test_trie_insert_and_search(self):
- """Test Trie insert and search."""
-
- class TrieNode:
- def __init__(self):
- self.children = {}
- self.is_end = False
-
- class Trie:
- def __init__(self):
- self.root = TrieNode()
-
- def insert(self, word):
- node = self.root
- for char in word:
- if char not in node.children:
- node.children[char] = TrieNode()
- node = node.children[char]
- node.is_end = True
-
- def search(self, word):
- node = self.root
- for char in word:
- if char not in node.children:
- return False
- node = node.children[char]
- return node.is_end
-
- trie = Trie()
- trie.insert("hello")
- trie.insert("help")
- assert trie.search("hello") is True
- assert trie.search("help") is True
- assert trie.search("hel") is False
- assert trie.search("world") is False
-
- def test_trie_prefix_search(self):
- """Test Trie prefix search."""
-
- class TrieNode:
- def __init__(self):
- self.children = {}
- self.is_end = False
-
- class Trie:
- def __init__(self):
- self.root = TrieNode()
-
- def insert(self, word):
- node = self.root
- for char in word:
- if char not in node.children:
- node.children[char] = TrieNode()
- node = node.children[char]
- node.is_end = True
-
- def starts_with(self, prefix):
- node = self.root
- for char in prefix:
- if char not in node.children:
- return False
- node = node.children[char]
- return True
-
- trie = Trie()
- trie.insert("hello")
- trie.insert("help")
- assert trie.starts_with("hel") is True
- assert trie.starts_with("wor") is False
-
- def test_trie_autocomplete(self):
- """Test Trie autocomplete suggestions."""
-
- class TrieNode:
- def __init__(self):
- self.children = {}
- self.is_end = False
-
- class Trie:
- def __init__(self):
- self.root = TrieNode()
-
- def insert(self, word):
- node = self.root
- for char in word:
- if char not in node.children:
- node.children[char] = TrieNode()
- node = node.children[char]
- node.is_end = True
-
- def autocomplete(self, prefix):
- node = self.root
- for char in prefix:
- if char not in node.children:
- return []
- node = node.children[char]
- return self._collect_words(node, prefix)
-
- def _collect_words(self, node, prefix):
- words = []
- if node.is_end:
- words.append(prefix)
- for char, child in node.children.items():
- words.extend(self._collect_words(child, prefix + char))
- return words
-
- trie = Trie()
- for word in ["hello", "help", "helper", "world"]:
- trie.insert(word)
- suggestions = trie.autocomplete("hel")
- assert "hello" in suggestions
- assert "help" in suggestions
- assert "helper" in suggestions
- assert "world" not in suggestions
-
-
-class TestGraphStructures:
- """Tests for graph data structure patterns."""
-
- def test_adjacency_list_representation(self):
- """Test adjacency list graph representation."""
-
- def create_graph():
- return {}
-
- def add_edge(graph, u, v, directed=False):
- if u not in graph:
- graph[u] = []
- graph[u].append(v)
- if not directed:
- if v not in graph:
- graph[v] = []
- graph[v].append(u)
-
- graph = create_graph()
- add_edge(graph, "A", "B")
- add_edge(graph, "A", "C")
- assert "B" in graph["A"]
- assert "C" in graph["A"]
- assert "A" in graph["B"]
-
- def test_bfs_traversal(self):
- """Test breadth-first search traversal."""
-
- def bfs(graph, start):
- visited = []
- queue = [start]
- while queue:
- node = queue.pop(0)
- if node not in visited:
- visited.append(node)
- queue.extend(
- n for n in graph.get(node, []) if n not in visited
- )
- return visited
-
- graph = {"A": ["B", "C"], "B": ["D"], "C": ["D"], "D": []}
- result = bfs(graph, "A")
- assert result[0] == "A"
- assert "B" in result
- assert "C" in result
- assert "D" in result
-
- def test_dfs_traversal(self):
- """Test depth-first search traversal."""
-
- def dfs(graph, start, visited=None):
- if visited is None:
- visited = []
- visited.append(start)
- for neighbor in graph.get(start, []):
- if neighbor not in visited:
- dfs(graph, neighbor, visited)
- return visited
-
- graph = {"A": ["B", "C"], "B": ["D"], "C": ["D"], "D": []}
- result = dfs(graph, "A")
- assert result[0] == "A"
- assert len(result) == 4
-
- def test_detect_cycle(self):
- """Test detecting cycle in directed graph."""
-
- def has_cycle(graph):
- visited = set()
- rec_stack = set()
-
- def dfs(node):
- visited.add(node)
- rec_stack.add(node)
- for neighbor in graph.get(node, []):
- if neighbor not in visited:
- if dfs(neighbor):
- return True
- elif neighbor in rec_stack:
- return True
- rec_stack.remove(node)
- return False
-
- for node in graph:
- if node not in visited:
- if dfs(node):
- return True
- return False
-
- # Acyclic graph
- acyclic = {"A": ["B"], "B": ["C"], "C": []}
- assert has_cycle(acyclic) is False
-
- # Cyclic graph
- cyclic = {"A": ["B"], "B": ["C"], "C": ["A"]}
- assert has_cycle(cyclic) is True
-
- def test_topological_sort(self):
- """Test topological sort of DAG."""
-
- def topological_sort(graph):
- visited = set()
- result = []
-
- def dfs(node):
- visited.add(node)
- for neighbor in graph.get(node, []):
- if neighbor not in visited:
- dfs(neighbor)
- result.insert(0, node)
-
- for node in graph:
- if node not in visited:
- dfs(node)
- return result
-
- graph = {"A": ["B", "C"], "B": ["D"], "C": ["D"], "D": []}
- result = topological_sort(graph)
- assert result.index("A") < result.index("B")
- assert result.index("A") < result.index("C")
- assert result.index("B") < result.index("D")
-
-
-class TestLinkedListStructures:
- """Tests for linked list patterns."""
-
- def test_singly_linked_list(self):
- """Test singly linked list operations."""
-
- @dataclass
- class Node:
- value: Any
- next: "Node" = None
-
- class LinkedList:
- def __init__(self):
- self.head = None
-
- def append(self, value):
- new_node = Node(value)
- if not self.head:
- self.head = new_node
- return
- current = self.head
- while current.next:
- current = current.next
- current.next = new_node
-
- def to_list(self):
- result = []
- current = self.head
- while current:
- result.append(current.value)
- current = current.next
- return result
-
- ll = LinkedList()
- ll.append(1)
- ll.append(2)
- ll.append(3)
- assert ll.to_list() == [1, 2, 3]
-
- def test_linked_list_reverse(self):
- """Test reversing a linked list."""
-
- @dataclass
- class Node:
- value: Any
- next: "Node" = None
-
- def reverse(head):
- prev = None
- current = head
- while current:
- next_node = current.next
- current.next = prev
- prev = current
- current = next_node
- return prev
-
- def to_list(head):
- result = []
- while head:
- result.append(head.value)
- head = head.next
- return result
-
- # Create 1 -> 2 -> 3
- head = Node(1, Node(2, Node(3)))
- reversed_head = reverse(head)
- assert to_list(reversed_head) == [3, 2, 1]
-
- def test_detect_cycle_in_list(self):
- """Test detecting cycle in linked list."""
-
- @dataclass
- class Node:
- value: Any
- next: "Node" = None
-
- def has_cycle(head):
- if not head:
- return False
- slow = head
- fast = head
- while fast and fast.next:
- slow = slow.next
- fast = fast.next.next
- if slow == fast:
- return True
- return False
-
- # No cycle
- no_cycle = Node(1, Node(2, Node(3)))
- assert has_cycle(no_cycle) is False
-
- # With cycle
- cycle_node = Node(2)
- with_cycle = Node(1, cycle_node)
- cycle_node.next = Node(3, cycle_node) # 3 points back to 2
- assert has_cycle(with_cycle) is True
-
- def test_find_middle_node(self):
- """Test finding middle node of linked list."""
-
- @dataclass
- class Node:
- value: Any
- next: "Node" = None
-
- def find_middle(head):
- slow = head
- fast = head
- while fast and fast.next:
- slow = slow.next
- fast = fast.next.next
- return slow.value if slow else None
-
- # Odd length: 1 -> 2 -> 3 -> 4 -> 5
- head = Node(1, Node(2, Node(3, Node(4, Node(5)))))
- assert find_middle(head) == 3
-
- # Even length: 1 -> 2 -> 3 -> 4
- head = Node(1, Node(2, Node(3, Node(4))))
- assert find_middle(head) == 3
-
-
-class TestStackPatterns:
- """Tests for stack data structure patterns."""
-
- def test_basic_stack_operations(self):
- """Test basic stack push/pop/peek."""
-
- class Stack:
- def __init__(self):
- self.items = []
-
- def push(self, item):
- self.items.append(item)
-
- def pop(self):
- if self.is_empty():
- return None
- return self.items.pop()
-
- def peek(self):
- if self.is_empty():
- return None
- return self.items[-1]
-
- def is_empty(self):
- return len(self.items) == 0
-
- def size(self):
- return len(self.items)
-
- stack = Stack()
- stack.push(1)
- stack.push(2)
- stack.push(3)
- assert stack.peek() == 3
- assert stack.pop() == 3
- assert stack.pop() == 2
- assert stack.size() == 1
-
- def test_balanced_parentheses(self):
- """Test checking balanced parentheses."""
-
- def is_balanced(s):
- stack = []
- pairs = {")": "(", "}": "{", "]": "["}
- for char in s:
- if char in "({[":
- stack.append(char)
- elif char in ")}]":
- if not stack or stack[-1] != pairs[char]:
- return False
- stack.pop()
- return len(stack) == 0
-
- assert is_balanced("()") is True
- assert is_balanced("({[]})") is True
- assert is_balanced("(]") is False
- assert is_balanced("((())") is False
-
- def test_min_stack(self):
- """Test stack that supports O(1) min operation."""
-
- class MinStack:
- def __init__(self):
- self.stack = []
- self.min_stack = []
-
- def push(self, val):
- self.stack.append(val)
- if not self.min_stack or val <= self.min_stack[-1]:
- self.min_stack.append(val)
-
- def pop(self):
- val = self.stack.pop()
- if val == self.min_stack[-1]:
- self.min_stack.pop()
- return val
-
- def get_min(self):
- return self.min_stack[-1] if self.min_stack else None
-
- ms = MinStack()
- ms.push(3)
- ms.push(1)
- ms.push(2)
- assert ms.get_min() == 1
- ms.pop()
- assert ms.get_min() == 1
- ms.pop()
- assert ms.get_min() == 3
-
-
-class TestQueuePatterns:
- """Tests for queue data structure patterns."""
-
- def test_basic_queue_operations(self):
- """Test basic queue enqueue/dequeue."""
-
- class Queue:
- def __init__(self):
- self.items = []
-
- def enqueue(self, item):
- self.items.append(item)
-
- def dequeue(self):
- if self.is_empty():
- return None
- return self.items.pop(0)
-
- def front(self):
- if self.is_empty():
- return None
- return self.items[0]
-
- def is_empty(self):
- return len(self.items) == 0
-
- queue = Queue()
- queue.enqueue(1)
- queue.enqueue(2)
- queue.enqueue(3)
- assert queue.front() == 1
- assert queue.dequeue() == 1
- assert queue.dequeue() == 2
-
- def test_circular_queue(self):
- """Test circular queue with fixed size."""
-
- class CircularQueue:
- def __init__(self, capacity):
- self.capacity = capacity
- self.items = [None] * capacity
- self.front = 0
- self.rear = 0
- self.size = 0
-
- def enqueue(self, item):
- if self.is_full():
- return False
- self.items[self.rear] = item
- self.rear = (self.rear + 1) % self.capacity
- self.size += 1
- return True
-
- def dequeue(self):
- if self.is_empty():
- return None
- item = self.items[self.front]
- self.front = (self.front + 1) % self.capacity
- self.size -= 1
- return item
-
- def is_empty(self):
- return self.size == 0
-
- def is_full(self):
- return self.size == self.capacity
-
- cq = CircularQueue(3)
- assert cq.enqueue(1) is True
- assert cq.enqueue(2) is True
- assert cq.enqueue(3) is True
- assert cq.enqueue(4) is False # Full
- assert cq.dequeue() == 1
- assert cq.enqueue(4) is True # Space now
-
- def test_priority_queue(self):
- """Test priority queue using heap."""
- import heapq
-
- class PriorityQueue:
- def __init__(self):
- self.heap = []
-
- def push(self, priority, item):
- heapq.heappush(self.heap, (priority, item))
-
- def pop(self):
- if not self.heap:
- return None
- return heapq.heappop(self.heap)[1]
-
- def peek(self):
- if not self.heap:
- return None
- return self.heap[0][1]
-
- pq = PriorityQueue()
- pq.push(3, "low")
- pq.push(1, "high")
- pq.push(2, "medium")
- assert pq.pop() == "high"
- assert pq.pop() == "medium"
- assert pq.pop() == "low"
-
-
-class TestHashMapPatterns:
- """Tests for hash map patterns."""
-
- def test_simple_hash_function(self):
- """Test simple hash function."""
-
- def simple_hash(key, size):
- h = 0
- for char in str(key):
- h = (h * 31 + ord(char)) % size
- return h
-
- # Same key should give same hash
- assert simple_hash("test", 100) == simple_hash("test", 100)
- # Different keys may give different hashes
- h1 = simple_hash("abc", 100)
- h2 = simple_hash("def", 100)
- # Just check they're valid indices
- assert 0 <= h1 < 100
- assert 0 <= h2 < 100
-
- def test_hash_map_with_chaining(self):
- """Test hash map with separate chaining."""
-
- class HashMap:
- def __init__(self, capacity=10):
- self.capacity = capacity
- self.buckets = [[] for _ in range(capacity)]
-
- def _hash(self, key):
- return hash(key) % self.capacity
-
- def put(self, key, value):
- bucket = self.buckets[self._hash(key)]
- for i, (k, v) in enumerate(bucket):
- if k == key:
- bucket[i] = (key, value)
- return
- bucket.append((key, value))
-
- def get(self, key, default=None):
- bucket = self.buckets[self._hash(key)]
- for k, v in bucket:
- if k == key:
- return v
- return default
-
- def delete(self, key):
- bucket = self.buckets[self._hash(key)]
- for i, (k, v) in enumerate(bucket):
- if k == key:
- del bucket[i]
- return True
- return False
-
- hm = HashMap()
- hm.put("a", 1)
- hm.put("b", 2)
- assert hm.get("a") == 1
- assert hm.get("b") == 2
- assert hm.get("c") is None
- hm.put("a", 10) # Update
- assert hm.get("a") == 10
- hm.delete("a")
- assert hm.get("a") is None
-
- def test_lru_cache_using_dict(self):
- """Test LRU cache implementation."""
- from collections import OrderedDict
-
- class LRUCache:
- def __init__(self, capacity):
- self.capacity = capacity
- self.cache = OrderedDict()
-
- def get(self, key):
- if key not in self.cache:
- return None
- self.cache.move_to_end(key)
- return self.cache[key]
-
- def put(self, key, value):
- if key in self.cache:
- self.cache.move_to_end(key)
- self.cache[key] = value
- if len(self.cache) > self.capacity:
- self.cache.popitem(last=False)
-
- lru = LRUCache(2)
- lru.put("a", 1)
- lru.put("b", 2)
- assert lru.get("a") == 1
- lru.put("c", 3) # Evicts "b"
- assert lru.get("b") is None
- assert lru.get("c") == 3
-
-
-class TestHeapPatterns:
- """Tests for heap data structure patterns."""
-
- def test_min_heap_operations(self):
- """Test min heap using heapq."""
- import heapq
-
- heap = []
- heapq.heappush(heap, 5)
- heapq.heappush(heap, 3)
- heapq.heappush(heap, 7)
- heapq.heappush(heap, 1)
- assert heapq.heappop(heap) == 1
- assert heapq.heappop(heap) == 3
-
- def test_max_heap_simulation(self):
- """Test max heap using negative values."""
- import heapq
-
- class MaxHeap:
- def __init__(self):
- self.heap = []
-
- def push(self, val):
- heapq.heappush(self.heap, -val)
-
- def pop(self):
- return -heapq.heappop(self.heap)
-
- def peek(self):
- return -self.heap[0] if self.heap else None
-
- mh = MaxHeap()
- mh.push(5)
- mh.push(3)
- mh.push(7)
- assert mh.pop() == 7
- assert mh.pop() == 5
-
- def test_k_smallest_elements(self):
- """Test finding k smallest elements."""
- import heapq
-
- def k_smallest(nums, k):
- return heapq.nsmallest(k, nums)
-
- assert k_smallest([5, 3, 8, 1, 9, 2], 3) == [1, 2, 3]
-
- def test_k_largest_elements(self):
- """Test finding k largest elements."""
- import heapq
-
- def k_largest(nums, k):
- return heapq.nlargest(k, nums)
-
- assert k_largest([5, 3, 8, 1, 9, 2], 3) == [9, 8, 5]
-
- def test_merge_k_sorted_lists(self):
- """Test merging k sorted lists."""
- import heapq
-
- def merge_k_sorted(lists):
- heap = []
- for i, lst in enumerate(lists):
- if lst:
- heapq.heappush(heap, (lst[0], i, 0))
- result = []
- while heap:
- val, list_idx, elem_idx = heapq.heappop(heap)
- result.append(val)
- if elem_idx + 1 < len(lists[list_idx]):
- heapq.heappush(
- heap,
- (lists[list_idx][elem_idx + 1], list_idx, elem_idx + 1),
- )
- return result
-
- lists = [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
- assert merge_k_sorted(lists) == [1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-
-class TestSetPatterns:
- """Tests for set data structure patterns."""
-
- def test_set_operations(self):
- """Test basic set operations."""
- set1 = {1, 2, 3, 4}
- set2 = {3, 4, 5, 6}
-
- assert set1.union(set2) == {1, 2, 3, 4, 5, 6}
- assert set1.intersection(set2) == {3, 4}
- assert set1.difference(set2) == {1, 2}
- assert set1.symmetric_difference(set2) == {1, 2, 5, 6}
-
- def test_subset_superset(self):
- """Test subset and superset checks."""
- parent = {1, 2, 3, 4, 5}
- child = {2, 3}
-
- assert child.issubset(parent) is True
- assert parent.issuperset(child) is True
- assert parent.issubset(child) is False
-
- def test_disjoint_sets(self):
- """Test disjoint set check."""
- set1 = {1, 2, 3}
- set2 = {4, 5, 6}
- set3 = {3, 4}
-
- assert set1.isdisjoint(set2) is True
- assert set1.isdisjoint(set3) is False
-
- def test_union_find(self):
- """Test Union-Find (Disjoint Set Union) structure."""
-
- class UnionFind:
- def __init__(self, n):
- self.parent = list(range(n))
- self.rank = [0] * n
-
- def find(self, x):
- if self.parent[x] != x:
- self.parent[x] = self.find(self.parent[x])
- return self.parent[x]
-
- def union(self, x, y):
- px, py = self.find(x), self.find(y)
- if px == py:
- return False
- if self.rank[px] < self.rank[py]:
- px, py = py, px
- self.parent[py] = px
- if self.rank[px] == self.rank[py]:
- self.rank[px] += 1
- return True
-
- def connected(self, x, y):
- return self.find(x) == self.find(y)
-
- uf = UnionFind(5)
- uf.union(0, 1)
- uf.union(2, 3)
- assert uf.connected(0, 1) is True
- assert uf.connected(2, 3) is True
- assert uf.connected(0, 2) is False
- uf.union(1, 2)
- assert uf.connected(0, 3) is True
-
-
-class TestBitManipulation:
- """Tests for bit manipulation patterns."""
-
- def test_bit_operations(self):
- """Test basic bit operations."""
-
- # Check if bit is set
- def is_bit_set(num, pos):
- return (num >> pos) & 1 == 1
-
- # Set a bit
- def set_bit(num, pos):
- return num | (1 << pos)
-
- # Clear a bit
- def clear_bit(num, pos):
- return num & ~(1 << pos)
-
- # Toggle a bit
- def toggle_bit(num, pos):
- return num ^ (1 << pos)
-
- assert is_bit_set(5, 0) is True # 5 = 101, bit 0 is set
- assert is_bit_set(5, 1) is False # bit 1 is not set
- assert set_bit(4, 0) == 5 # 4 = 100, set bit 0 -> 101 = 5
- assert clear_bit(5, 0) == 4 # 5 = 101, clear bit 0 -> 100 = 4
- assert toggle_bit(5, 1) == 7 # 5 = 101, toggle bit 1 -> 111 = 7
-
- def test_count_set_bits(self):
- """Test counting set bits (population count)."""
-
- def count_bits(n):
- count = 0
- while n:
- count += n & 1
- n >>= 1
- return count
-
- assert count_bits(0) == 0
- assert count_bits(7) == 3 # 111
- assert count_bits(255) == 8 # 11111111
-
- def test_power_of_two(self):
- """Test checking if number is power of two."""
-
- def is_power_of_two(n):
- return n > 0 and (n & (n - 1)) == 0
-
- assert is_power_of_two(1) is True # 2^0
- assert is_power_of_two(2) is True # 2^1
- assert is_power_of_two(8) is True # 2^3
- assert is_power_of_two(6) is False
-
- def test_single_number(self):
- """Test finding single number using XOR."""
-
- def find_single(nums):
- result = 0
- for num in nums:
- result ^= num
- return result
-
- # Every element appears twice except one
- assert find_single([2, 3, 2, 4, 3]) == 4
- assert find_single([1, 1, 2, 2, 3]) == 3
-
- def test_swap_without_temp(self):
- """Test swapping without temporary variable."""
-
- def swap(a, b):
- a = a ^ b
- b = a ^ b
- a = a ^ b
- return a, b
-
- assert swap(5, 10) == (10, 5)
- assert swap(0, 100) == (100, 0)
diff --git a/tests/news/test_data_transformation_patterns_behavior.py b/tests/news/test_data_transformation_patterns_behavior.py
deleted file mode 100644
index 6dc794074d..0000000000
--- a/tests/news/test_data_transformation_patterns_behavior.py
+++ /dev/null
@@ -1,543 +0,0 @@
-"""
-Deep behavioral tests for data transformation patterns.
-Tests card serialization, deserialization, normalization,
-merging, and format conversion logic.
-"""
-
-from datetime import datetime, timezone
-import json
-
-
-# --- Card serialization patterns ---
-
-
-class TestCardSerialization:
- """Tests for card to dict serialization."""
-
- def _serialize_card(self, card):
- """Serialize card to dict."""
- return {
- "id": card.get("id"),
- "card_type": card.get("card_type", "news"),
- "headline": card.get("headline", ""),
- "summary": card.get("summary", ""),
- "impact_score": card.get("impact_score", 5),
- "category": card.get("category", "General"),
- "topics": card.get("topics", []),
- "created_at": card.get("created_at").isoformat()
- if card.get("created_at")
- else None,
- }
-
- def test_preserves_id(self):
- card = {"id": "card-123"}
- result = self._serialize_card(card)
- assert result["id"] == "card-123"
-
- def test_defaults_card_type(self):
- card = {"id": "1"}
- result = self._serialize_card(card)
- assert result["card_type"] == "news"
-
- def test_formats_datetime(self):
- card = {
- "id": "1",
- "created_at": datetime(2025, 6, 15, tzinfo=timezone.utc),
- }
- result = self._serialize_card(card)
- assert "2025-06-15" in result["created_at"]
-
- def test_empty_topics(self):
- card = {"id": "1"}
- result = self._serialize_card(card)
- assert result["topics"] == []
-
-
-# --- Card deserialization patterns ---
-
-
-class TestCardDeserialization:
- """Tests for dict to card deserialization."""
-
- def _deserialize_card(self, data):
- """Deserialize dict to card."""
- card = {
- "id": data.get("id"),
- "card_type": data.get("card_type", "news"),
- "headline": data.get("headline", ""),
- "summary": data.get("summary", ""),
- "impact_score": data.get("impact_score", 5),
- "topics": data.get("topics", []),
- }
- if data.get("created_at"):
- if isinstance(data["created_at"], str):
- card["created_at"] = datetime.fromisoformat(data["created_at"])
- else:
- card["created_at"] = data["created_at"]
- return card
-
- def test_parses_id(self):
- data = {"id": "card-456"}
- card = self._deserialize_card(data)
- assert card["id"] == "card-456"
-
- def test_parses_datetime_string(self):
- data = {"id": "1", "created_at": "2025-06-15T12:00:00+00:00"}
- card = self._deserialize_card(data)
- assert isinstance(card["created_at"], datetime)
-
- def test_preserves_datetime_object(self):
- dt = datetime(2025, 6, 15, tzinfo=timezone.utc)
- data = {"id": "1", "created_at": dt}
- card = self._deserialize_card(data)
- assert card["created_at"] == dt
-
-
-# --- JSON serialization patterns ---
-
-
-class TestJSONSerialization:
- """Tests for JSON serialization patterns."""
-
- def _to_json_safe(self, data):
- """Convert data to JSON-safe dict."""
-
- def convert(obj):
- if isinstance(obj, datetime):
- return obj.isoformat()
- if isinstance(obj, set):
- return list(obj)
- if isinstance(obj, dict):
- return {k: convert(v) for k, v in obj.items()}
- if isinstance(obj, list):
- return [convert(i) for i in obj]
- return obj
-
- return convert(data)
-
- def test_converts_datetime(self):
- data = {"time": datetime(2025, 6, 15, tzinfo=timezone.utc)}
- result = self._to_json_safe(data)
- assert isinstance(result["time"], str)
-
- def test_converts_set(self):
- data = {"items": {1, 2, 3}}
- result = self._to_json_safe(data)
- assert isinstance(result["items"], list)
- assert len(result["items"]) == 3
-
- def test_nested_conversion(self):
- data = {"outer": {"inner": datetime(2025, 1, 1, tzinfo=timezone.utc)}}
- result = self._to_json_safe(data)
- assert isinstance(result["outer"]["inner"], str)
-
- def test_can_serialize_to_json(self):
- data = {"time": datetime(2025, 6, 15, tzinfo=timezone.utc)}
- safe = self._to_json_safe(data)
- json_str = json.dumps(safe)
- assert isinstance(json_str, str)
-
-
-# --- Data normalization patterns ---
-
-
-class TestDataNormalization:
- """Tests for data normalization patterns."""
-
- def _normalize_text(self, text):
- """Normalize text fields."""
- if not text:
- return ""
- return " ".join(text.strip().split())
-
- def test_trims_whitespace(self):
- result = self._normalize_text(" hello world ")
- assert result == "hello world"
-
- def test_collapses_spaces(self):
- result = self._normalize_text("hello world")
- assert result == "hello world"
-
- def test_handles_newlines(self):
- result = self._normalize_text("hello\nworld")
- assert result == "hello world"
-
- def test_handles_none(self):
- result = self._normalize_text(None)
- assert result == ""
-
- def test_handles_empty(self):
- result = self._normalize_text("")
- assert result == ""
-
-
-class TestScoreNormalization:
- """Tests for score normalization patterns."""
-
- def _normalize_score(self, score, min_val=0, max_val=10):
- """Normalize score to range."""
- if score is None:
- return (min_val + max_val) / 2
- return max(min_val, min(max_val, score))
-
- def test_within_range(self):
- result = self._normalize_score(5)
- assert result == 5
-
- def test_below_min(self):
- result = self._normalize_score(-5)
- assert result == 0
-
- def test_above_max(self):
- result = self._normalize_score(15)
- assert result == 10
-
- def test_none_uses_middle(self):
- result = self._normalize_score(None)
- assert result == 5
-
-
-# --- Topic normalization patterns ---
-
-
-class TestTopicNormalization:
- """Tests for topic normalization patterns."""
-
- def _normalize_topics(self, topics):
- """Normalize topic list."""
- if not topics:
- return []
- normalized = []
- seen = set()
- for topic in topics:
- if not topic:
- continue
- clean = topic.strip().lower()
- if clean and clean not in seen:
- seen.add(clean)
- normalized.append(clean)
- return normalized
-
- def test_lowercase(self):
- result = self._normalize_topics(["AI", "ML"])
- assert result == ["ai", "ml"]
-
- def test_removes_duplicates(self):
- result = self._normalize_topics(["AI", "ai", "Ai"])
- assert result == ["ai"]
-
- def test_strips_whitespace(self):
- result = self._normalize_topics([" AI ", " ML "])
- assert result == ["ai", "ml"]
-
- def test_removes_empty(self):
- result = self._normalize_topics(["AI", "", None, "ML"])
- assert result == ["ai", "ml"]
-
-
-# --- Data merging patterns ---
-
-
-class TestDataMerging:
- """Tests for data merging patterns."""
-
- def _merge_dicts(self, base, updates):
- """Merge updates into base dict."""
- result = base.copy()
- for key, value in updates.items():
- if value is not None:
- result[key] = value
- return result
-
- def test_overwrites_values(self):
- base = {"a": 1, "b": 2}
- updates = {"b": 3}
- result = self._merge_dicts(base, updates)
- assert result["b"] == 3
-
- def test_preserves_unmodified(self):
- base = {"a": 1, "b": 2}
- updates = {"c": 3}
- result = self._merge_dicts(base, updates)
- assert result["a"] == 1
- assert result["b"] == 2
-
- def test_skips_none(self):
- base = {"a": 1}
- updates = {"a": None}
- result = self._merge_dicts(base, updates)
- assert result["a"] == 1
-
-
-class TestDeepMerging:
- """Tests for deep dict merging patterns."""
-
- def _deep_merge(self, base, updates):
- """Deep merge dicts."""
- result = base.copy()
- for key, value in updates.items():
- if (
- key in result
- and isinstance(result[key], dict)
- and isinstance(value, dict)
- ):
- result[key] = self._deep_merge(result[key], value)
- elif value is not None:
- result[key] = value
- return result
-
- def test_merges_nested(self):
- base = {"a": {"b": 1, "c": 2}}
- updates = {"a": {"c": 3}}
- result = self._deep_merge(base, updates)
- assert result["a"]["b"] == 1
- assert result["a"]["c"] == 3
-
- def test_overwrites_non_dict(self):
- base = {"a": 1}
- updates = {"a": {"b": 2}}
- result = self._deep_merge(base, updates)
- assert result["a"] == {"b": 2}
-
-
-# --- List operations patterns ---
-
-
-class TestListDeduplication:
- """Tests for list deduplication patterns."""
-
- def _deduplicate_by_id(self, items):
- """Deduplicate items by ID."""
- seen = set()
- result = []
- for item in items:
- item_id = item.get("id")
- if item_id not in seen:
- seen.add(item_id)
- result.append(item)
- return result
-
- def test_removes_duplicates(self):
- items = [
- {"id": "1", "name": "A"},
- {"id": "2", "name": "B"},
- {"id": "1", "name": "A copy"},
- ]
- result = self._deduplicate_by_id(items)
- assert len(result) == 2
-
- def test_keeps_first(self):
- items = [
- {"id": "1", "name": "First"},
- {"id": "1", "name": "Second"},
- ]
- result = self._deduplicate_by_id(items)
- assert result[0]["name"] == "First"
-
-
-class TestListSorting:
- """Tests for list sorting patterns."""
-
- def _sort_by_key(self, items, key, reverse=False):
- """Sort items by key."""
- return sorted(items, key=lambda x: x.get(key, 0), reverse=reverse)
-
- def test_sorts_ascending(self):
- items = [{"score": 3}, {"score": 1}, {"score": 2}]
- result = self._sort_by_key(items, "score")
- assert result[0]["score"] == 1
- assert result[2]["score"] == 3
-
- def test_sorts_descending(self):
- items = [{"score": 1}, {"score": 3}]
- result = self._sort_by_key(items, "score", reverse=True)
- assert result[0]["score"] == 3
-
-
-# --- Format conversion patterns ---
-
-
-class TestDateTimeFormatConversion:
- """Tests for datetime format conversions."""
-
- def _to_timestamp(self, dt):
- """Convert datetime to Unix timestamp."""
- if not dt:
- return None
- return dt.timestamp()
-
- def _from_timestamp(self, ts):
- """Convert Unix timestamp to datetime."""
- if not ts:
- return None
- return datetime.fromtimestamp(ts, tz=timezone.utc)
-
- def test_to_timestamp(self):
- dt = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- ts = self._to_timestamp(dt)
- assert isinstance(ts, float)
-
- def test_from_timestamp(self):
- ts = 1750000000
- dt = self._from_timestamp(ts)
- assert isinstance(dt, datetime)
-
- def test_roundtrip(self):
- original = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- ts = self._to_timestamp(original)
- recovered = self._from_timestamp(ts)
- assert abs((recovered - original).total_seconds()) < 1
-
-
-class TestIntervalFormatConversion:
- """Tests for interval format conversions."""
-
- def _minutes_to_seconds(self, minutes):
- """Convert minutes to seconds."""
- return minutes * 60
-
- def _seconds_to_minutes(self, seconds):
- """Convert seconds to minutes."""
- return seconds // 60
-
- def _format_interval(self, minutes):
- """Format interval as human-readable."""
- if minutes < 60:
- return f"{minutes} minutes"
- hours = minutes // 60
- remaining = minutes % 60
- if remaining == 0:
- return f"{hours} hour{'s' if hours > 1 else ''}"
- return f"{hours}h {remaining}m"
-
- def test_minutes_to_seconds(self):
- assert self._minutes_to_seconds(30) == 1800
-
- def test_seconds_to_minutes(self):
- assert self._seconds_to_minutes(3600) == 60
-
- def test_format_minutes(self):
- assert self._format_interval(30) == "30 minutes"
-
- def test_format_hour(self):
- assert self._format_interval(60) == "1 hour"
-
- def test_format_hours(self):
- assert self._format_interval(120) == "2 hours"
-
- def test_format_mixed(self):
- assert self._format_interval(90) == "1h 30m"
-
-
-# --- Metadata extraction patterns ---
-
-
-class TestMetadataExtraction:
- """Tests for metadata extraction patterns."""
-
- def _extract_metadata(self, data, keys):
- """Extract specified metadata keys."""
- return {k: data.get(k) for k in keys if k in data}
-
- def test_extracts_existing(self):
- data = {"a": 1, "b": 2, "c": 3}
- result = self._extract_metadata(data, ["a", "b"])
- assert result == {"a": 1, "b": 2}
-
- def test_ignores_missing(self):
- data = {"a": 1}
- result = self._extract_metadata(data, ["a", "b"])
- assert result == {"a": 1}
-
- def test_empty_keys(self):
- data = {"a": 1}
- result = self._extract_metadata(data, [])
- assert result == {}
-
-
-# --- Field mapping patterns ---
-
-
-class TestFieldMapping:
- """Tests for field mapping patterns."""
-
- def _map_fields(self, data, mapping):
- """Map fields from one structure to another."""
- result = {}
- for target, source in mapping.items():
- if source in data:
- result[target] = data[source]
- return result
-
- def test_renames_fields(self):
- data = {"old_name": "value"}
- mapping = {"new_name": "old_name"}
- result = self._map_fields(data, mapping)
- assert result == {"new_name": "value"}
-
- def test_multiple_mappings(self):
- data = {"a": 1, "b": 2}
- mapping = {"x": "a", "y": "b"}
- result = self._map_fields(data, mapping)
- assert result == {"x": 1, "y": 2}
-
-
-# --- Default value patterns ---
-
-
-class TestDefaultValues:
- """Tests for default value patterns."""
-
- def _with_defaults(self, data, defaults):
- """Apply defaults to data."""
- result = defaults.copy()
- result.update({k: v for k, v in data.items() if v is not None})
- return result
-
- def test_applies_defaults(self):
- data = {"a": 1}
- defaults = {"a": 0, "b": 2}
- result = self._with_defaults(data, defaults)
- assert result["a"] == 1
- assert result["b"] == 2
-
- def test_none_uses_default(self):
- data = {"a": None}
- defaults = {"a": 10}
- result = self._with_defaults(data, defaults)
- assert result["a"] == 10
-
-
-# --- Safe access patterns ---
-
-
-class TestSafeAccess:
- """Tests for safe nested access patterns."""
-
- def _safe_get(self, data, *keys, default=None):
- """Safely get nested value."""
- result = data
- for key in keys:
- if isinstance(result, dict):
- result = result.get(key)
- else:
- return default
- if result is None:
- return default
- return result
-
- def test_single_key(self):
- data = {"a": 1}
- assert self._safe_get(data, "a") == 1
-
- def test_nested_keys(self):
- data = {"a": {"b": {"c": 3}}}
- assert self._safe_get(data, "a", "b", "c") == 3
-
- def test_missing_key(self):
- data = {"a": 1}
- assert self._safe_get(data, "b", default=0) == 0
-
- def test_missing_nested(self):
- data = {"a": {}}
- assert self._safe_get(data, "a", "b", "c", default="x") == "x"
diff --git a/tests/news/test_edge_cases_behavior.py b/tests/news/test_edge_cases_behavior.py
deleted file mode 100644
index 9dfaa95072..0000000000
--- a/tests/news/test_edge_cases_behavior.py
+++ /dev/null
@@ -1,427 +0,0 @@
-"""
-Deep behavioral tests for edge cases across the news module.
-Tests boundary conditions, special values, error scenarios,
-and unusual input combinations.
-"""
-
-from datetime import datetime, timedelta, timezone
-
-
-# --- Empty input handling ---
-
-
-class TestEmptyInputHandling:
- """Tests for handling empty inputs."""
-
- def test_empty_string_as_query(self):
- query = ""
- assert query == ""
- assert len(query) == 0
-
- def test_empty_list_as_topics(self):
- topics = []
- assert len(topics) == 0
- assert not topics
-
- def test_empty_dict_as_preferences(self):
- prefs = {}
- assert not prefs
- assert prefs.get("interests", {}) == {}
-
- def test_none_handling_in_get(self):
- data = {}
- result = data.get("missing")
- assert result is None
-
- def test_empty_string_truthiness(self):
- assert not ""
- assert bool("") is False
-
-
-# --- None value handling ---
-
-
-class TestNoneValueHandling:
- """Tests for handling None values."""
-
- def test_none_in_list(self):
- items = [1, None, 3]
- assert None in items
- filtered = [i for i in items if i is not None]
- assert len(filtered) == 2
-
- def test_none_as_dict_value(self):
- data = {"key": None}
- assert data["key"] is None
- assert data.get("key") is None
-
- def test_none_default_or(self):
- value = None
- result = value or "default"
- assert result == "default"
-
- def test_none_and_expression(self):
- value = None
- result = value and "something"
- assert result is None
-
- def test_is_none_vs_falsy(self):
- assert None is None
- assert not None
- # 0 and "" are falsy but not None
- assert 0 != None # noqa: E711
- assert "" != None # noqa: E711
-
-
-# --- Boundary value testing ---
-
-
-class TestBoundaryValues:
- """Tests for boundary values."""
-
- def test_zero_limit(self):
- limit = 0
- items = [1, 2, 3]
- result = items[:limit]
- assert result == []
-
- def test_limit_exceeds_list(self):
- limit = 100
- items = [1, 2, 3]
- result = items[:limit]
- assert result == [1, 2, 3]
-
- def test_negative_offset(self):
- offset = -1
- clamped = max(0, offset)
- assert clamped == 0
-
- def test_max_int_limit(self):
- import sys
-
- max_int = sys.maxsize
- # Should not crash
- assert max_int > 0
-
-
-class TestTimeBoundaries:
- """Tests for time boundary conditions."""
-
- def test_zero_hours_ago(self):
- hours = 0
- cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
- now = datetime.now(timezone.utc)
- # Cutoff should be essentially now
- assert abs((cutoff - now).total_seconds()) < 1
-
- def test_very_old_date(self):
- old_date = datetime(2000, 1, 1, tzinfo=timezone.utc)
- now = datetime.now(timezone.utc)
- hours = (now - old_date).total_seconds() / 3600
- assert hours > 200000 # More than 20 years
-
- def test_future_date(self):
- future = datetime.now(timezone.utc) + timedelta(days=365)
- now = datetime.now(timezone.utc)
- delta = (future - now).days
- # Could be 364 or 365 depending on time of day
- assert 364 <= delta <= 365
-
-
-# --- Special string handling ---
-
-
-class TestSpecialStringHandling:
- """Tests for special string values."""
-
- def test_unicode_in_query(self):
- query = "新闻 AI 技术"
- assert len(query) > 0
- assert "AI" in query
-
- def test_emoji_in_topic(self):
- topic = "AI News 🤖"
- assert len(topic) > 0
-
- def test_very_long_string(self):
- long_str = "A" * 10000
- assert len(long_str) == 10000
- truncated = long_str[:100]
- assert len(truncated) == 100
-
- def test_whitespace_only_string(self):
- ws = " \t\n "
- assert ws.strip() == ""
- assert not ws.strip()
-
- def test_special_characters(self):
- special = "query with <>&\"' characters"
- assert "<" in special
- assert ">" in special
-
-
-# --- List edge cases ---
-
-
-class TestListEdgeCases:
- """Tests for list edge cases."""
-
- def test_single_item_list(self):
- items = [1]
- assert items[0] == 1
- assert len(items) == 1
-
- def test_max_on_single_item(self):
- items = [{"score": 5}]
- result = max(items, key=lambda x: x["score"])
- assert result["score"] == 5
-
- def test_sorted_empty_list(self):
- items = []
- result = sorted(items)
- assert result == []
-
- def test_duplicate_items(self):
- items = ["a", "b", "a"]
- unique = list(set(items))
- assert len(unique) == 2
-
-
-# --- Dict edge cases ---
-
-
-class TestDictEdgeCases:
- """Tests for dictionary edge cases."""
-
- def test_get_with_default(self):
- data = {}
- result = data.get("missing", "default")
- assert result == "default"
-
- def test_nested_get(self):
- data = {"outer": {"inner": "value"}}
- result = data.get("outer", {}).get("inner")
- assert result == "value"
-
- def test_nested_get_missing_outer(self):
- data = {}
- result = data.get("outer", {}).get("inner")
- assert result is None
-
- def test_update_overwrites(self):
- data = {"key": "old"}
- data.update({"key": "new"})
- assert data["key"] == "new"
-
-
-# --- Number edge cases ---
-
-
-class TestNumberEdgeCases:
- """Tests for number edge cases."""
-
- def test_division_by_zero_avoided(self):
- total = 0
- rate = 0 if total == 0 else 10 / total
- assert rate == 0
-
- def test_float_comparison(self):
- a = 0.1 + 0.2
- b = 0.3
- # Direct comparison may fail due to floating point
- assert abs(a - b) < 0.0001
-
- def test_min_max_on_scores(self):
- scores = [1, 5, 10, 3]
- assert min(scores) == 1
- assert max(scores) == 10
-
- def test_negative_score(self):
- score = -1
- clamped = max(0, score)
- assert clamped == 0
-
-
-# --- DateTime edge cases ---
-
-
-class TestDateTimeEdgeCases:
- """Tests for datetime edge cases."""
-
- def test_naive_datetime_comparison(self):
- naive = datetime(2025, 6, 15, 10, 0, 0)
- aware = datetime(2025, 6, 15, 10, 0, 0, tzinfo=timezone.utc)
- # Cannot directly compare, but can make naive aware
- naive_as_aware = naive.replace(tzinfo=timezone.utc)
- assert naive_as_aware == aware
-
- def test_isoformat_roundtrip(self):
- dt = datetime(2025, 6, 15, 10, 30, 0, tzinfo=timezone.utc)
- iso = dt.isoformat()
- parsed = datetime.fromisoformat(iso)
- assert parsed == dt
-
- def test_timedelta_zero(self):
- delta = timedelta(seconds=0)
- assert delta.total_seconds() == 0
-
-
-# --- Filter edge cases ---
-
-
-class TestFilterEdgeCases:
- """Tests for filter logic edge cases."""
-
- def test_filter_all_items(self):
- items = [1, 2, 3, 4, 5]
- filtered = [i for i in items if i > 10]
- assert filtered == []
-
- def test_filter_no_items(self):
- items = [1, 2, 3]
- filtered = [i for i in items if i > 0]
- assert filtered == [1, 2, 3]
-
- def test_filter_with_none_values(self):
- items = [1, None, 3, None, 5]
- filtered = [i for i in items if i is not None]
- assert filtered == [1, 3, 5]
-
-
-# --- Subscription status transitions ---
-
-
-class TestStatusTransitionEdgeCases:
- """Tests for status transition edge cases."""
-
- def test_same_status_transition(self):
- current = "active"
- new = "active"
- # No change
- assert current == new
-
- def test_invalid_status_ignored(self):
- valid = ["active", "paused", "expired"]
- status = "invalid"
- is_valid = status in valid
- assert is_valid is False
-
-
-# --- Score calculation edge cases ---
-
-
-class TestScoreCalculationEdgeCases:
- """Tests for score calculation edge cases."""
-
- def test_all_weights_zero(self):
- weights = {"a": 0, "b": 0, "c": 0}
- total = sum(weights.values())
- assert total == 0
-
- def test_negative_weight(self):
- weights = {"positive": 2, "negative": -1}
- total = sum(weights.values())
- assert total == 1
-
- def test_very_high_score_capped(self):
- raw_score = 1000
- capped = min(10, raw_score)
- assert capped == 10
-
- def test_very_low_score_floored(self):
- raw_score = -5
- floored = max(0, raw_score)
- assert floored == 0
-
-
-# --- String manipulation edge cases ---
-
-
-class TestStringManipulationEdgeCases:
- """Tests for string manipulation edge cases."""
-
- def test_split_empty_string(self):
- s = ""
- parts = s.split()
- assert parts == []
-
- def test_join_empty_list(self):
- parts = []
- result = " ".join(parts)
- assert result == ""
-
- def test_replace_not_found(self):
- s = "hello world"
- result = s.replace("xyz", "abc")
- assert result == "hello world"
-
- def test_lower_empty_string(self):
- s = ""
- result = s.lower()
- assert result == ""
-
-
-# --- Collection operations edge cases ---
-
-
-class TestCollectionOperationsEdgeCases:
- """Tests for collection operations edge cases."""
-
- def test_set_from_empty_list(self):
- items = []
- unique = set(items)
- assert len(unique) == 0
-
- def test_extend_empty_list(self):
- items = []
- items.extend([1, 2])
- assert items == [1, 2]
-
- def test_clear_list(self):
- items = [1, 2, 3]
- items.clear()
- assert len(items) == 0
-
- def test_copy_vs_reference(self):
- original = [1, 2, 3]
- copy = original.copy()
- copy.append(4)
- assert len(original) == 3
- assert len(copy) == 4
-
-
-# --- Enum-like string comparisons ---
-
-
-class TestEnumLikeComparisons:
- """Tests for enum-like string comparisons."""
-
- def test_case_sensitive_comparison(self):
- status = "Active"
- assert status != "active"
- assert status.lower() == "active"
-
- def test_whitespace_in_status(self):
- status = " active "
- assert status.strip() == "active"
-
-
-# --- Concurrent access patterns ---
-
-
-class TestConcurrentAccessPatterns:
- """Tests for patterns used in concurrent access."""
-
- def test_copy_before_iteration(self):
- items = {1, 2, 3}
- removed = []
- for item in items.copy():
- removed.append(item)
- assert len(removed) == 3
-
- def test_dict_get_with_lock_pattern(self):
- cache = {"user1": "data1"}
- # Simulate locked access
- key = "user1"
- result = cache.get(key)
- assert result == "data1"
diff --git a/tests/news/test_error_handling_patterns_behavior.py b/tests/news/test_error_handling_patterns_behavior.py
deleted file mode 100644
index 00d8c05177..0000000000
--- a/tests/news/test_error_handling_patterns_behavior.py
+++ /dev/null
@@ -1,665 +0,0 @@
-"""
-Deep behavioral tests for error handling patterns.
-Tests error categorization, retry logic, circuit breakers,
-and graceful degradation patterns.
-"""
-
-from datetime import datetime, timezone
-import random
-
-
-# --- Error categorization patterns ---
-
-
-class TestErrorCategorization:
- """Tests for error categorization patterns."""
-
- def _categorize_error(self, error):
- """Categorize an error for handling."""
- error_str = str(error).lower()
-
- if any(w in error_str for w in ["timeout", "timed out"]):
- return "timeout"
- if any(w in error_str for w in ["connection", "network", "refused"]):
- return "network"
- if any(
- w in error_str
- for w in ["auth", "permission", "forbidden", "unauthorized"]
- ):
- return "auth"
- if any(w in error_str for w in ["not found", "404"]):
- return "not_found"
- if any(w in error_str for w in ["rate limit", "429", "too many"]):
- return "rate_limit"
- if any(
- w in error_str for w in ["invalid", "validation", "bad request"]
- ):
- return "validation"
- return "unknown"
-
- def test_timeout_categorized(self):
- assert self._categorize_error("Connection timed out") == "timeout"
- assert self._categorize_error("Request timeout") == "timeout"
-
- def test_network_categorized(self):
- assert self._categorize_error("Connection refused") == "network"
- assert self._categorize_error("Network error") == "network"
-
- def test_auth_categorized(self):
- assert self._categorize_error("Unauthorized access") == "auth"
- assert self._categorize_error("Permission denied") == "auth"
-
- def test_not_found_categorized(self):
- assert self._categorize_error("Resource not found") == "not_found"
- assert self._categorize_error("404 error") == "not_found"
-
- def test_rate_limit_categorized(self):
- assert self._categorize_error("Rate limit exceeded") == "rate_limit"
- assert self._categorize_error("429 Too Many Requests") == "rate_limit"
-
- def test_validation_categorized(self):
- assert self._categorize_error("Invalid input") == "validation"
- assert self._categorize_error("Bad request") == "validation"
-
- def test_unknown_categorized(self):
- assert self._categorize_error("Something went wrong") == "unknown"
-
-
-class TestErrorSeverity:
- """Tests for error severity determination."""
-
- def _get_severity(self, error_category):
- """Get severity level for error category."""
- severities = {
- "validation": "low",
- "not_found": "low",
- "auth": "medium",
- "timeout": "medium",
- "network": "high",
- "rate_limit": "medium",
- "unknown": "high",
- }
- return severities.get(error_category, "high")
-
- def test_validation_low_severity(self):
- assert self._get_severity("validation") == "low"
-
- def test_network_high_severity(self):
- assert self._get_severity("network") == "high"
-
- def test_unknown_high_severity(self):
- assert self._get_severity("unknown") == "high"
-
-
-# --- Retry logic patterns ---
-
-
-class TestRetryDecision:
- """Tests for retry decision patterns."""
-
- def _should_retry(self, error_category, attempt, max_attempts=3):
- """Decide if error should be retried."""
- if attempt >= max_attempts:
- return False
- retryable = ["timeout", "network", "rate_limit"]
- return error_category in retryable
-
- def test_retryable_on_first_attempt(self):
- assert self._should_retry("timeout", 0) is True
- assert self._should_retry("network", 0) is True
-
- def test_not_retryable_categories(self):
- assert self._should_retry("auth", 0) is False
- assert self._should_retry("validation", 0) is False
- assert self._should_retry("not_found", 0) is False
-
- def test_no_retry_after_max_attempts(self):
- assert self._should_retry("timeout", 3) is False
-
- def test_retry_before_max_attempts(self):
- assert self._should_retry("timeout", 2) is True
-
-
-class TestExponentialBackoff:
- """Tests for exponential backoff patterns."""
-
- def _calculate_backoff(
- self, attempt, base_delay=1.0, max_delay=60.0, jitter=True
- ):
- """Calculate exponential backoff delay."""
- delay = base_delay * (2**attempt)
- delay = min(delay, max_delay)
- if jitter:
- delay = delay * (0.5 + random.random() * 0.5)
- return delay
-
- def _calculate_backoff_no_jitter(
- self, attempt, base_delay=1.0, max_delay=60.0
- ):
- """Calculate backoff without jitter."""
- delay = base_delay * (2**attempt)
- return min(delay, max_delay)
-
- def test_first_attempt_base_delay(self):
- delay = self._calculate_backoff_no_jitter(0)
- assert delay == 1.0
-
- def test_exponential_increase(self):
- delay0 = self._calculate_backoff_no_jitter(0)
- delay1 = self._calculate_backoff_no_jitter(1)
- delay2 = self._calculate_backoff_no_jitter(2)
- assert delay1 == delay0 * 2
- assert delay2 == delay1 * 2
-
- def test_capped_at_max(self):
- delay = self._calculate_backoff_no_jitter(100, max_delay=60.0)
- assert delay == 60.0
-
- def test_jitter_varies_delay(self):
- delays = [self._calculate_backoff(1, jitter=True) for _ in range(10)]
- # With jitter, delays should vary
- assert len(set(delays)) > 1
-
-
-# --- Circuit breaker patterns ---
-
-
-class TestCircuitBreaker:
- """Tests for circuit breaker patterns."""
-
- def _create_circuit_breaker(self, failure_threshold=5, recovery_timeout=30):
- """Create a circuit breaker."""
- return {
- "state": "closed", # closed, open, half_open
- "failure_count": 0,
- "failure_threshold": failure_threshold,
- "recovery_timeout": recovery_timeout,
- "last_failure_time": None,
- }
-
- def _record_failure(self, breaker):
- """Record a failure in the circuit breaker."""
- breaker["failure_count"] += 1
- breaker["last_failure_time"] = datetime.now(timezone.utc)
- if breaker["failure_count"] >= breaker["failure_threshold"]:
- breaker["state"] = "open"
-
- def _record_success(self, breaker):
- """Record a success in the circuit breaker."""
- breaker["failure_count"] = 0
- breaker["state"] = "closed"
-
- def _is_call_allowed(self, breaker):
- """Check if call is allowed through circuit breaker."""
- if breaker["state"] == "closed":
- return True
- if breaker["state"] == "open":
- # Check if recovery timeout has passed
- if breaker["last_failure_time"]:
- elapsed = (
- datetime.now(timezone.utc) - breaker["last_failure_time"]
- ).total_seconds()
- if elapsed >= breaker["recovery_timeout"]:
- breaker["state"] = "half_open"
- return True
- return False
- if breaker["state"] == "half_open":
- return True
- return False
-
- def test_starts_closed(self):
- breaker = self._create_circuit_breaker()
- assert breaker["state"] == "closed"
-
- def test_allows_calls_when_closed(self):
- breaker = self._create_circuit_breaker()
- assert self._is_call_allowed(breaker) is True
-
- def test_opens_after_threshold(self):
- breaker = self._create_circuit_breaker(failure_threshold=3)
- for _ in range(3):
- self._record_failure(breaker)
- assert breaker["state"] == "open"
-
- def test_blocks_when_open(self):
- breaker = self._create_circuit_breaker()
- breaker["state"] = "open"
- breaker["last_failure_time"] = datetime.now(timezone.utc)
- assert self._is_call_allowed(breaker) is False
-
- def test_success_resets(self):
- breaker = self._create_circuit_breaker()
- breaker["failure_count"] = 3
- self._record_success(breaker)
- assert breaker["failure_count"] == 0
- assert breaker["state"] == "closed"
-
-
-class TestCircuitBreakerHalfOpen:
- """Tests for circuit breaker half-open state."""
-
- def _transition_to_half_open(self, breaker):
- """Transition breaker to half-open state."""
- breaker["state"] = "half_open"
- return breaker
-
- def _handle_half_open_result(self, breaker, success):
- """Handle result in half-open state."""
- if success:
- breaker["state"] = "closed"
- breaker["failure_count"] = 0
- else:
- breaker["state"] = "open"
- breaker["last_failure_time"] = datetime.now(timezone.utc)
-
- def test_success_closes_breaker(self):
- breaker = {"state": "half_open", "failure_count": 0}
- self._handle_half_open_result(breaker, True)
- assert breaker["state"] == "closed"
-
- def test_failure_opens_breaker(self):
- breaker = {
- "state": "half_open",
- "failure_count": 0,
- "last_failure_time": None,
- }
- self._handle_half_open_result(breaker, False)
- assert breaker["state"] == "open"
-
-
-# --- Graceful degradation patterns ---
-
-
-class TestGracefulDegradation:
- """Tests for graceful degradation patterns."""
-
- def _get_with_fallback(self, primary_func, fallback_value):
- """Get value with fallback on error."""
- try:
- return primary_func()
- except Exception:
- return fallback_value
-
- def _get_with_cache_fallback(self, fetch_func, cache, key):
- """Get fresh value or use cached value on error."""
- try:
- value = fetch_func()
- cache[key] = value
- return value, True # value, is_fresh
- except Exception:
- if key in cache:
- return cache[key], False # Stale cache
- raise
-
- def test_primary_succeeds(self):
- result = self._get_with_fallback(lambda: "primary", "fallback")
- assert result == "primary"
-
- def test_fallback_on_error(self):
- def failing():
- raise Exception("Error")
-
- result = self._get_with_fallback(failing, "fallback")
- assert result == "fallback"
-
- def test_fresh_value_returned(self):
- cache = {}
- value, is_fresh = self._get_with_cache_fallback(
- lambda: "fresh", cache, "key"
- )
- assert value == "fresh"
- assert is_fresh is True
-
- def test_stale_cache_on_error(self):
- cache = {"key": "stale"}
-
- def failing():
- raise Exception("Error")
-
- value, is_fresh = self._get_with_cache_fallback(failing, cache, "key")
- assert value == "stale"
- assert is_fresh is False
-
-
-class TestPartialResults:
- """Tests for partial result handling patterns."""
-
- def _collect_partial_results(self, sources, fetch_func):
- """Collect results from multiple sources, tolerating failures."""
- results = []
- errors = []
- for source in sources:
- try:
- result = fetch_func(source)
- results.append({"source": source, "data": result})
- except Exception as e:
- errors.append({"source": source, "error": str(e)})
- return {"results": results, "errors": errors}
-
- def test_all_succeed(self):
- sources = ["a", "b", "c"]
- outcome = self._collect_partial_results(sources, lambda s: f"data-{s}")
- assert len(outcome["results"]) == 3
- assert len(outcome["errors"]) == 0
-
- def test_partial_failure(self):
- def fetch(source):
- if source == "b":
- raise Exception("Failed")
- return f"data-{source}"
-
- outcome = self._collect_partial_results(["a", "b", "c"], fetch)
- assert len(outcome["results"]) == 2
- assert len(outcome["errors"]) == 1
-
- def test_all_fail(self):
- def failing(source):
- raise Exception("Failed")
-
- outcome = self._collect_partial_results(["a", "b"], failing)
- assert len(outcome["results"]) == 0
- assert len(outcome["errors"]) == 2
-
-
-# --- Error response patterns ---
-
-
-class TestErrorResponse:
- """Tests for error response building patterns."""
-
- def _build_error_response(
- self, error, status_code=500, include_details=False
- ):
- """Build error response."""
- response = {
- "success": False,
- "error": {
- "code": status_code,
- "message": self._get_user_message(error),
- },
- }
- if include_details:
- response["error"]["details"] = str(error)
- return response
-
- def _get_user_message(self, error):
- """Get user-friendly error message."""
- error_str = str(error).lower()
- if "not found" in error_str:
- return "The requested resource was not found."
- if "unauthorized" in error_str or "auth" in error_str:
- return "Authentication required."
- if "forbidden" in error_str:
- return "You don't have permission to access this resource."
- if "timeout" in error_str:
- return "The request timed out. Please try again."
- return "An unexpected error occurred. Please try again later."
-
- def test_has_success_false(self):
- response = self._build_error_response("Error")
- assert response["success"] is False
-
- def test_has_status_code(self):
- response = self._build_error_response("Error", status_code=404)
- assert response["error"]["code"] == 404
-
- def test_friendly_not_found_message(self):
- response = self._build_error_response("Resource not found")
- assert "not found" in response["error"]["message"].lower()
-
- def test_includes_details_when_requested(self):
- response = self._build_error_response(
- "Specific error", include_details=True
- )
- assert "Specific error" in response["error"]["details"]
-
-
-# --- Error logging patterns ---
-
-
-class TestErrorLogging:
- """Tests for error logging patterns."""
-
- def _format_error_log(self, error, context=None):
- """Format error for logging."""
- log = {
- "timestamp": datetime.now(timezone.utc).isoformat(),
- "error_type": type(error).__name__
- if hasattr(error, "__class__")
- else "Unknown",
- "message": str(error),
- }
- if context:
- log["context"] = context
- return log
-
- def _should_alert(self, error_category, count_in_window):
- """Check if error should trigger alert."""
- alert_thresholds = {
- "auth": 10,
- "network": 5,
- "timeout": 10,
- "unknown": 3,
- }
- threshold = alert_thresholds.get(error_category, 5)
- return count_in_window >= threshold
-
- def test_log_has_timestamp(self):
- log = self._format_error_log(Exception("Test"))
- assert "timestamp" in log
-
- def test_log_has_message(self):
- log = self._format_error_log(Exception("Test error"))
- assert log["message"] == "Test error"
-
- def test_log_includes_context(self):
- log = self._format_error_log(Exception("Error"), {"user_id": "123"})
- assert log["context"]["user_id"] == "123"
-
- def test_alert_threshold(self):
- assert self._should_alert("network", 5) is True
- assert self._should_alert("network", 4) is False
-
-
-# --- Timeout handling patterns ---
-
-
-class TestTimeoutHandling:
- """Tests for timeout handling patterns."""
-
- def _with_timeout(self, func, timeout_seconds, default=None):
- """Execute function with timeout (simulated)."""
- # In real code, this would use threading or asyncio
- # Here we just test the pattern
- try:
- return func()
- except TimeoutError:
- return default
-
- def _calculate_dynamic_timeout(self, operation_type, payload_size=0):
- """Calculate dynamic timeout based on operation."""
- base_timeouts = {
- "search": 10,
- "research": 60,
- "download": 30,
- "api_call": 5,
- }
- base = base_timeouts.get(operation_type, 10)
- # Add time for larger payloads
- size_factor = payload_size / 1000000 # MB
- return base + (size_factor * 5)
-
- def test_returns_result_on_success(self):
- result = self._with_timeout(lambda: "success", 10)
- assert result == "success"
-
- def test_returns_default_on_timeout(self):
- def timeout_func():
- raise TimeoutError()
-
- result = self._with_timeout(timeout_func, 10, default="fallback")
- assert result == "fallback"
-
- def test_research_has_longer_timeout(self):
- search_timeout = self._calculate_dynamic_timeout("search")
- research_timeout = self._calculate_dynamic_timeout("research")
- assert research_timeout > search_timeout
-
- def test_timeout_scales_with_size(self):
- small = self._calculate_dynamic_timeout("download", payload_size=100000)
- large = self._calculate_dynamic_timeout(
- "download", payload_size=10000000
- )
- assert large > small
-
-
-# --- Error recovery patterns ---
-
-
-class TestErrorRecovery:
- """Tests for error recovery patterns."""
-
- def _attempt_recovery(self, error_category):
- """Determine recovery action for error."""
- recovery_actions = {
- "timeout": "retry_with_backoff",
- "network": "retry_with_backoff",
- "rate_limit": "wait_and_retry",
- "auth": "refresh_credentials",
- "not_found": "return_empty",
- "validation": "return_error",
- }
- return recovery_actions.get(error_category, "log_and_fail")
-
- def test_timeout_retries(self):
- action = self._attempt_recovery("timeout")
- assert action == "retry_with_backoff"
-
- def test_rate_limit_waits(self):
- action = self._attempt_recovery("rate_limit")
- assert action == "wait_and_retry"
-
- def test_auth_refreshes(self):
- action = self._attempt_recovery("auth")
- assert action == "refresh_credentials"
-
- def test_validation_returns_error(self):
- action = self._attempt_recovery("validation")
- assert action == "return_error"
-
-
-class TestStateRecovery:
- """Tests for state recovery patterns."""
-
- def _save_checkpoint(self, state, checkpoints, max_checkpoints=5):
- """Save state checkpoint."""
- checkpoint = {
- "timestamp": datetime.now(timezone.utc),
- "state": state.copy(),
- }
- checkpoints.append(checkpoint)
- while len(checkpoints) > max_checkpoints:
- checkpoints.pop(0)
- return len(checkpoints)
-
- def _restore_checkpoint(self, checkpoints, index=-1):
- """Restore from checkpoint."""
- if not checkpoints:
- return None
- return checkpoints[index]["state"]
-
- def test_saves_checkpoint(self):
- checkpoints = []
- self._save_checkpoint({"progress": 50}, checkpoints)
- assert len(checkpoints) == 1
-
- def test_limits_checkpoints(self):
- checkpoints = []
- for i in range(10):
- self._save_checkpoint(
- {"progress": i}, checkpoints, max_checkpoints=3
- )
- assert len(checkpoints) == 3
-
- def test_restores_latest(self):
- checkpoints = []
- self._save_checkpoint({"v": 1}, checkpoints)
- self._save_checkpoint({"v": 2}, checkpoints)
- restored = self._restore_checkpoint(checkpoints)
- assert restored["v"] == 2
-
- def test_restores_specific(self):
- checkpoints = []
- self._save_checkpoint({"v": 1}, checkpoints)
- self._save_checkpoint({"v": 2}, checkpoints)
- restored = self._restore_checkpoint(checkpoints, index=0)
- assert restored["v"] == 1
-
-
-# --- Health check patterns ---
-
-
-class TestHealthCheckPatterns:
- """Tests for health check patterns."""
-
- def _check_component_health(self, component, check_func):
- """Check health of a component."""
- try:
- start = datetime.now(timezone.utc)
- result = check_func()
- elapsed = (datetime.now(timezone.utc) - start).total_seconds()
- return {
- "component": component,
- "healthy": result,
- "latency_ms": elapsed * 1000,
- }
- except Exception as e:
- return {
- "component": component,
- "healthy": False,
- "error": str(e),
- }
-
- def _aggregate_health(self, checks):
- """Aggregate health checks."""
- all_healthy = all(c.get("healthy", False) for c in checks)
- unhealthy = [
- c["component"] for c in checks if not c.get("healthy", False)
- ]
- return {
- "status": "healthy" if all_healthy else "unhealthy",
- "unhealthy_components": unhealthy,
- }
-
- def test_healthy_component(self):
- result = self._check_component_health("db", lambda: True)
- assert result["healthy"] is True
-
- def test_unhealthy_component(self):
- result = self._check_component_health("db", lambda: False)
- assert result["healthy"] is False
-
- def test_failed_check(self):
- def failing():
- raise Exception("Connection failed")
-
- result = self._check_component_health("db", failing)
- assert result["healthy"] is False
- assert "error" in result
-
- def test_aggregate_all_healthy(self):
- checks = [
- {"component": "db", "healthy": True},
- {"component": "cache", "healthy": True},
- ]
- result = self._aggregate_health(checks)
- assert result["status"] == "healthy"
-
- def test_aggregate_some_unhealthy(self):
- checks = [
- {"component": "db", "healthy": True},
- {"component": "cache", "healthy": False},
- ]
- result = self._aggregate_health(checks)
- assert result["status"] == "unhealthy"
- assert "cache" in result["unhealthy_components"]
diff --git a/tests/news/test_event_processing_patterns_behavior.py b/tests/news/test_event_processing_patterns_behavior.py
deleted file mode 100644
index f8c5d1305e..0000000000
--- a/tests/news/test_event_processing_patterns_behavior.py
+++ /dev/null
@@ -1,615 +0,0 @@
-"""
-Deep behavioral tests for event processing patterns.
-Tests event creation, publishing, subscription,
-handling, and replay logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-import uuid
-
-
-# --- Event creation patterns ---
-
-
-class TestEventCreation:
- """Tests for event creation patterns."""
-
- def _create_event(self, event_type, payload, **metadata):
- """Create an event."""
- return {
- "id": str(uuid.uuid4()),
- "type": event_type,
- "payload": payload,
- "timestamp": datetime.now(timezone.utc),
- "metadata": metadata,
- }
-
- def test_has_id(self):
- event = self._create_event("user.created", {"user_id": "123"})
- assert "id" in event
- assert len(event["id"]) > 0
-
- def test_has_type(self):
- event = self._create_event("user.created", {"user_id": "123"})
- assert event["type"] == "user.created"
-
- def test_has_payload(self):
- event = self._create_event("user.created", {"user_id": "123"})
- assert event["payload"]["user_id"] == "123"
-
- def test_has_timestamp(self):
- event = self._create_event("user.created", {})
- assert "timestamp" in event
-
- def test_includes_metadata(self):
- event = self._create_event("user.created", {}, source="api", version=1)
- assert event["metadata"]["source"] == "api"
- assert event["metadata"]["version"] == 1
-
-
-class TestEventTypeValidation:
- """Tests for event type validation."""
-
- def _validate_event_type(self, event_type):
- """Validate event type format."""
- if not event_type or not isinstance(event_type, str):
- return False
- parts = event_type.split(".")
- if len(parts) < 2:
- return False
- return all(p.isidentifier() for p in parts)
-
- def test_valid_two_part_type(self):
- assert self._validate_event_type("user.created") is True
-
- def test_valid_three_part_type(self):
- assert self._validate_event_type("subscription.card.updated") is True
-
- def test_invalid_single_part(self):
- assert self._validate_event_type("created") is False
-
- def test_invalid_empty(self):
- assert self._validate_event_type("") is False
-
-
-# --- Event publishing patterns ---
-
-
-class TestEventPublishing:
- """Tests for event publishing patterns."""
-
- def _publish_event(self, event_bus, event):
- """Publish event to bus."""
- if "events" not in event_bus:
- event_bus["events"] = []
- event_bus["events"].append(event)
- return len(event_bus["events"])
-
- def _publish_batch(self, event_bus, events):
- """Publish multiple events."""
- if "events" not in event_bus:
- event_bus["events"] = []
- event_bus["events"].extend(events)
- return len(events)
-
- def test_publish_adds_to_bus(self):
- bus = {}
- event = {"id": "1", "type": "test"}
- self._publish_event(bus, event)
- assert len(bus["events"]) == 1
-
- def test_publish_returns_count(self):
- bus = {}
- count = self._publish_event(bus, {"id": "1"})
- assert count == 1
-
- def test_publish_batch(self):
- bus = {}
- events = [{"id": "1"}, {"id": "2"}, {"id": "3"}]
- published = self._publish_batch(bus, events)
- assert published == 3
- assert len(bus["events"]) == 3
-
-
-# --- Event subscription patterns ---
-
-
-class TestEventSubscription:
- """Tests for event subscription patterns."""
-
- def _subscribe(self, subscriptions, event_type, handler_id):
- """Subscribe to an event type."""
- if event_type not in subscriptions:
- subscriptions[event_type] = []
- subscriptions[event_type].append(handler_id)
- return True
-
- def _unsubscribe(self, subscriptions, event_type, handler_id):
- """Unsubscribe from an event type."""
- if event_type in subscriptions:
- if handler_id in subscriptions[event_type]:
- subscriptions[event_type].remove(handler_id)
- return True
- return False
-
- def _get_handlers(self, subscriptions, event_type):
- """Get handlers for an event type."""
- return subscriptions.get(event_type, [])
-
- def test_subscribe_adds_handler(self):
- subs = {}
- self._subscribe(subs, "user.created", "handler1")
- assert "handler1" in subs["user.created"]
-
- def test_unsubscribe_removes_handler(self):
- subs = {"user.created": ["handler1"]}
- result = self._unsubscribe(subs, "user.created", "handler1")
- assert result is True
- assert "handler1" not in subs["user.created"]
-
- def test_get_handlers(self):
- subs = {"user.created": ["h1", "h2"]}
- handlers = self._get_handlers(subs, "user.created")
- assert len(handlers) == 2
-
-
-class TestWildcardSubscription:
- """Tests for wildcard event subscription patterns."""
-
- def _matches_pattern(self, event_type, pattern):
- """Check if event type matches subscription pattern."""
- if pattern == "*":
- return True
- if pattern.endswith(".*"):
- prefix = pattern[:-2]
- return event_type.startswith(prefix + ".")
- return event_type == pattern
-
- def _get_matching_handlers(self, subscriptions, event_type):
- """Get all handlers that match event type."""
- handlers = []
- for pattern, pattern_handlers in subscriptions.items():
- if self._matches_pattern(event_type, pattern):
- handlers.extend(pattern_handlers)
- return handlers
-
- def test_exact_match(self):
- assert self._matches_pattern("user.created", "user.created") is True
- assert self._matches_pattern("user.created", "user.updated") is False
-
- def test_wildcard_all(self):
- assert self._matches_pattern("user.created", "*") is True
- assert self._matches_pattern("subscription.updated", "*") is True
-
- def test_prefix_wildcard(self):
- assert self._matches_pattern("user.created", "user.*") is True
- assert self._matches_pattern("user.updated", "user.*") is True
- assert self._matches_pattern("card.created", "user.*") is False
-
- def test_get_matching_handlers(self):
- subs = {
- "user.created": ["h1"],
- "user.*": ["h2"],
- "*": ["h3"],
- }
- handlers = self._get_matching_handlers(subs, "user.created")
- assert "h1" in handlers
- assert "h2" in handlers
- assert "h3" in handlers
-
-
-# --- Event handling patterns ---
-
-
-class TestEventHandling:
- """Tests for event handling patterns."""
-
- def _handle_event(self, event, handler):
- """Handle an event with a handler."""
- try:
- result = handler(event)
- return {"success": True, "result": result}
- except Exception as e:
- return {"success": False, "error": str(e)}
-
- def _dispatch_event(self, event, handlers):
- """Dispatch event to multiple handlers."""
- results = []
- for handler in handlers:
- result = self._handle_event(event, handler)
- results.append(result)
- return results
-
- def test_successful_handling(self):
- event = {"type": "test", "payload": {"value": 42}}
-
- def handler(e):
- return e["payload"]["value"] * 2
-
- result = self._handle_event(event, handler)
- assert result["success"] is True
- assert result["result"] == 84
-
- def test_failed_handling(self):
- event = {"type": "test"}
-
- def failing_handler(e):
- raise ValueError("Handler failed")
-
- result = self._handle_event(event, failing_handler)
- assert result["success"] is False
- assert "Handler failed" in result["error"]
-
- def test_dispatch_to_multiple(self):
- event = {"type": "test", "payload": {"v": 1}}
- handlers = [
- lambda e: e["payload"]["v"],
- lambda e: e["payload"]["v"] * 2,
- ]
- results = self._dispatch_event(event, handlers)
- assert len(results) == 2
- assert results[0]["result"] == 1
- assert results[1]["result"] == 2
-
-
-# --- Event ordering patterns ---
-
-
-class TestEventOrdering:
- """Tests for event ordering patterns."""
-
- def _sort_by_timestamp(self, events):
- """Sort events by timestamp."""
- return sorted(events, key=lambda e: e.get("timestamp", datetime.min))
-
- def _get_sequence_number(self, event_store, event_type):
- """Get next sequence number for event type."""
- key = f"seq_{event_type}"
- current = event_store.get(key, 0)
- event_store[key] = current + 1
- return current + 1
-
- def test_sorts_by_timestamp(self):
- now = datetime.now(timezone.utc)
- events = [
- {"id": "2", "timestamp": now + timedelta(seconds=1)},
- {"id": "1", "timestamp": now},
- {"id": "3", "timestamp": now + timedelta(seconds=2)},
- ]
- sorted_events = self._sort_by_timestamp(events)
- assert sorted_events[0]["id"] == "1"
- assert sorted_events[2]["id"] == "3"
-
- def test_sequence_numbers_increment(self):
- store = {}
- seq1 = self._get_sequence_number(store, "user")
- seq2 = self._get_sequence_number(store, "user")
- seq3 = self._get_sequence_number(store, "user")
- assert seq1 == 1
- assert seq2 == 2
- assert seq3 == 3
-
-
-# --- Event filtering patterns ---
-
-
-class TestEventFiltering:
- """Tests for event filtering patterns."""
-
- def _filter_by_type(self, events, event_type):
- """Filter events by type."""
- return [e for e in events if e.get("type") == event_type]
-
- def _filter_by_time_range(self, events, start=None, end=None):
- """Filter events by time range."""
- filtered = []
- for event in events:
- timestamp = event.get("timestamp")
- if timestamp is None:
- continue
- if start and timestamp < start:
- continue
- if end and timestamp > end:
- continue
- filtered.append(event)
- return filtered
-
- def _filter_by_payload(self, events, **criteria):
- """Filter events by payload criteria."""
- filtered = []
- for event in events:
- payload = event.get("payload", {})
- matches = all(payload.get(k) == v for k, v in criteria.items())
- if matches:
- filtered.append(event)
- return filtered
-
- def test_filter_by_type(self):
- events = [
- {"type": "user.created"},
- {"type": "card.created"},
- {"type": "user.created"},
- ]
- filtered = self._filter_by_type(events, "user.created")
- assert len(filtered) == 2
-
- def test_filter_by_time_range(self):
- now = datetime.now(timezone.utc)
- events = [
- {"timestamp": now - timedelta(hours=2)},
- {"timestamp": now - timedelta(hours=1)},
- {"timestamp": now},
- ]
- start = now - timedelta(hours=1, minutes=30)
- filtered = self._filter_by_time_range(events, start=start)
- assert len(filtered) == 2
-
- def test_filter_by_payload(self):
- events = [
- {"payload": {"user_id": "1", "status": "active"}},
- {"payload": {"user_id": "2", "status": "inactive"}},
- {"payload": {"user_id": "3", "status": "active"}},
- ]
- filtered = self._filter_by_payload(events, status="active")
- assert len(filtered) == 2
-
-
-# --- Event replay patterns ---
-
-
-class TestEventReplay:
- """Tests for event replay patterns."""
-
- def _replay_events(self, events, handler, from_sequence=0):
- """Replay events from a sequence number."""
- replayed = 0
- for event in events:
- if event.get("sequence", 0) > from_sequence:
- handler(event)
- replayed += 1
- return replayed
-
- def _create_snapshot(self, state, last_event_id):
- """Create a snapshot for replay optimization."""
- return {
- "state": state.copy(),
- "last_event_id": last_event_id,
- "created_at": datetime.now(timezone.utc),
- }
-
- def test_replay_from_sequence(self):
- events = [
- {"sequence": 1, "type": "test"},
- {"sequence": 2, "type": "test"},
- {"sequence": 3, "type": "test"},
- ]
- handled = []
- replayed = self._replay_events(events, handled.append, from_sequence=1)
- assert replayed == 2
-
- def test_snapshot_creation(self):
- state = {"count": 10, "last_update": "2025-01-01"}
- snapshot = self._create_snapshot(state, "event-100")
- assert snapshot["state"]["count"] == 10
- assert snapshot["last_event_id"] == "event-100"
-
-
-# --- Event deduplication patterns ---
-
-
-class TestEventDeduplication:
- """Tests for event deduplication patterns."""
-
- def _is_duplicate(self, event, seen_ids):
- """Check if event is a duplicate."""
- event_id = event.get("id")
- if event_id in seen_ids:
- return True
- seen_ids.add(event_id)
- return False
-
- def _deduplicate(self, events):
- """Remove duplicate events."""
- seen = set()
- unique = []
- for event in events:
- if event.get("id") not in seen:
- seen.add(event.get("id"))
- unique.append(event)
- return unique
-
- def test_detects_duplicate(self):
- seen = {"event-1", "event-2"}
- event = {"id": "event-1"}
- assert self._is_duplicate(event, seen) is True
-
- def test_new_event_not_duplicate(self):
- seen = {"event-1"}
- event = {"id": "event-2"}
- assert self._is_duplicate(event, seen) is False
- assert "event-2" in seen
-
- def test_deduplicate_list(self):
- events = [
- {"id": "1", "value": "a"},
- {"id": "2", "value": "b"},
- {"id": "1", "value": "a"}, # duplicate
- ]
- unique = self._deduplicate(events)
- assert len(unique) == 2
-
-
-# --- Event versioning patterns ---
-
-
-class TestEventVersioning:
- """Tests for event versioning patterns."""
-
- def _create_versioned_event(self, event_type, payload, version=1):
- """Create a versioned event."""
- return {
- "type": event_type,
- "version": version,
- "payload": payload,
- }
-
- def _is_compatible(self, event_version, handler_version):
- """Check if event version is compatible with handler."""
- return event_version <= handler_version
-
- def _upgrade_event(self, event, from_version, to_version, upgrades):
- """Upgrade event through version chain."""
- current = event.copy()
- for v in range(from_version, to_version):
- if v in upgrades:
- current = upgrades[v](current)
- current["version"] = to_version
- return current
-
- def test_create_versioned_event(self):
- event = self._create_versioned_event(
- "user.created", {"name": "test"}, version=2
- )
- assert event["version"] == 2
-
- def test_compatibility_check(self):
- assert self._is_compatible(1, 2) is True # Can handle older
- assert self._is_compatible(3, 2) is False # Can't handle newer
-
- def test_upgrade_event(self):
- event = {"version": 1, "payload": {"name": "test"}}
- upgrades = {
- 1: lambda e: {**e, "payload": {**e["payload"], "status": "active"}},
- }
- upgraded = self._upgrade_event(event, 1, 2, upgrades)
- assert upgraded["version"] == 2
- assert upgraded["payload"]["status"] == "active"
-
-
-# --- Dead letter queue patterns ---
-
-
-class TestDeadLetterQueue:
- """Tests for dead letter queue patterns."""
-
- def _move_to_dlq(self, dlq, event, error):
- """Move failed event to dead letter queue."""
- dlq_entry = {
- "original_event": event,
- "error": str(error),
- "failed_at": datetime.now(timezone.utc),
- "retry_count": event.get("_retry_count", 0) + 1,
- }
- dlq.append(dlq_entry)
- return len(dlq)
-
- def _should_move_to_dlq(self, event, max_retries=3):
- """Check if event should go to DLQ after max retries."""
- return event.get("_retry_count", 0) >= max_retries
-
- def test_move_to_dlq(self):
- dlq = []
- event = {"id": "1", "type": "test"}
- self._move_to_dlq(dlq, event, "Processing failed")
- assert len(dlq) == 1
- assert dlq[0]["original_event"] == event
-
- def test_should_move_after_retries(self):
- event = {"_retry_count": 3}
- assert self._should_move_to_dlq(event) is True
-
- def test_should_not_move_before_max(self):
- event = {"_retry_count": 1}
- assert self._should_move_to_dlq(event) is False
-
-
-# --- Event correlation patterns ---
-
-
-class TestEventCorrelation:
- """Tests for event correlation patterns."""
-
- def _correlate_events(self, events, correlation_id):
- """Find all events with same correlation ID."""
- return [e for e in events if e.get("correlation_id") == correlation_id]
-
- def _build_event_chain(self, events, correlation_id):
- """Build ordered chain of correlated events."""
- correlated = self._correlate_events(events, correlation_id)
- return sorted(
- correlated, key=lambda e: e.get("timestamp", datetime.min)
- )
-
- def test_correlate_events(self):
- events = [
- {"id": "1", "correlation_id": "req-1"},
- {"id": "2", "correlation_id": "req-2"},
- {"id": "3", "correlation_id": "req-1"},
- ]
- correlated = self._correlate_events(events, "req-1")
- assert len(correlated) == 2
-
- def test_build_event_chain(self):
- now = datetime.now(timezone.utc)
- events = [
- {
- "id": "3",
- "correlation_id": "req-1",
- "timestamp": now + timedelta(seconds=2),
- },
- {"id": "1", "correlation_id": "req-1", "timestamp": now},
- {
- "id": "2",
- "correlation_id": "req-1",
- "timestamp": now + timedelta(seconds=1),
- },
- ]
- chain = self._build_event_chain(events, "req-1")
- assert chain[0]["id"] == "1"
- assert chain[2]["id"] == "3"
-
-
-# --- Event aggregation patterns ---
-
-
-class TestEventAggregation:
- """Tests for event aggregation patterns."""
-
- def _aggregate_by_type(self, events):
- """Aggregate events by type."""
- aggregated = {}
- for event in events:
- event_type = event.get("type", "unknown")
- if event_type not in aggregated:
- aggregated[event_type] = []
- aggregated[event_type].append(event)
- return aggregated
-
- def _count_by_type(self, events):
- """Count events by type."""
- counts = {}
- for event in events:
- event_type = event.get("type", "unknown")
- counts[event_type] = counts.get(event_type, 0) + 1
- return counts
-
- def test_aggregate_by_type(self):
- events = [
- {"type": "user.created"},
- {"type": "card.created"},
- {"type": "user.created"},
- ]
- aggregated = self._aggregate_by_type(events)
- assert len(aggregated["user.created"]) == 2
- assert len(aggregated["card.created"]) == 1
-
- def test_count_by_type(self):
- events = [
- {"type": "a"},
- {"type": "b"},
- {"type": "a"},
- {"type": "a"},
- ]
- counts = self._count_by_type(events)
- assert counts["a"] == 3
- assert counts["b"] == 1
diff --git a/tests/news/test_exceptions_logic_behavior.py b/tests/news/test_exceptions_logic_behavior.py
deleted file mode 100644
index 3fe6184050..0000000000
--- a/tests/news/test_exceptions_logic_behavior.py
+++ /dev/null
@@ -1,442 +0,0 @@
-"""
-Deep behavioral tests for exceptions.py pure logic.
-Tests exception structure, status codes, error codes,
-to_dict conversion, and exception inheritance.
-"""
-
-
-# --- NewsAPIException base structure ---
-
-
-class TestNewsAPIExceptionStructure:
- """Tests for base NewsAPIException structure."""
-
- def _create_exception(
- self, message, status_code=500, error_code=None, details=None
- ):
- return {
- "message": message,
- "status_code": status_code,
- "error_code": error_code or "NewsAPIException",
- "details": details or {},
- }
-
- def test_has_message(self):
- exc = self._create_exception("Test error")
- assert exc["message"] == "Test error"
-
- def test_default_status_code_500(self):
- exc = self._create_exception("Error")
- assert exc["status_code"] == 500
-
- def test_custom_status_code(self):
- exc = self._create_exception("Error", status_code=400)
- assert exc["status_code"] == 400
-
- def test_default_error_code_from_class(self):
- exc = self._create_exception("Error")
- assert exc["error_code"] == "NewsAPIException"
-
- def test_custom_error_code(self):
- exc = self._create_exception("Error", error_code="CUSTOM_ERROR")
- assert exc["error_code"] == "CUSTOM_ERROR"
-
- def test_default_empty_details(self):
- exc = self._create_exception("Error")
- assert exc["details"] == {}
-
- def test_custom_details(self):
- exc = self._create_exception("Error", details={"key": "value"})
- assert exc["details"]["key"] == "value"
-
-
-# --- to_dict conversion ---
-
-
-class TestToDictConversion:
- """Tests for to_dict method structure."""
-
- def _to_dict(self, message, error_code, status_code, details):
- result = {
- "error": message,
- "error_code": error_code,
- "status_code": status_code,
- }
- if details:
- result["details"] = details
- return result
-
- def test_includes_error(self):
- result = self._to_dict("Test error", "CODE", 500, {})
- assert result["error"] == "Test error"
-
- def test_includes_error_code(self):
- result = self._to_dict("Error", "TEST_CODE", 500, {})
- assert result["error_code"] == "TEST_CODE"
-
- def test_includes_status_code(self):
- result = self._to_dict("Error", "CODE", 404, {})
- assert result["status_code"] == 404
-
- def test_includes_details_when_present(self):
- result = self._to_dict("Error", "CODE", 500, {"key": "val"})
- assert "details" in result
- assert result["details"]["key"] == "val"
-
- def test_excludes_details_when_empty(self):
- result = self._to_dict("Error", "CODE", 500, {})
- assert "details" not in result
-
-
-# --- NewsFeatureDisabledException ---
-
-
-class TestNewsFeatureDisabledException:
- """Tests for NewsFeatureDisabledException."""
-
- def _create_disabled_exception(self, message="News system is disabled"):
- return {
- "message": message,
- "status_code": 503,
- "error_code": "NEWS_DISABLED",
- "details": {},
- }
-
- def test_default_message(self):
- exc = self._create_disabled_exception()
- assert exc["message"] == "News system is disabled"
-
- def test_status_code_503(self):
- exc = self._create_disabled_exception()
- assert exc["status_code"] == 503
-
- def test_error_code_news_disabled(self):
- exc = self._create_disabled_exception()
- assert exc["error_code"] == "NEWS_DISABLED"
-
-
-# --- InvalidLimitException ---
-
-
-class TestInvalidLimitException:
- """Tests for InvalidLimitException."""
-
- def _create_limit_exception(self, limit):
- return {
- "message": f"Invalid limit: {limit}. Limit must be at least 1",
- "status_code": 400,
- "error_code": "INVALID_LIMIT",
- "details": {"provided_limit": limit, "min_limit": 1},
- }
-
- def test_message_includes_limit(self):
- exc = self._create_limit_exception(0)
- assert "0" in exc["message"]
-
- def test_status_code_400(self):
- exc = self._create_limit_exception(0)
- assert exc["status_code"] == 400
-
- def test_details_include_provided_limit(self):
- exc = self._create_limit_exception(-5)
- assert exc["details"]["provided_limit"] == -5
-
- def test_details_include_min_limit(self):
- exc = self._create_limit_exception(0)
- assert exc["details"]["min_limit"] == 1
-
-
-# --- SubscriptionNotFoundException ---
-
-
-class TestSubscriptionNotFoundException:
- """Tests for SubscriptionNotFoundException."""
-
- def _create_not_found_exception(self, subscription_id):
- return {
- "message": f"Subscription not found: {subscription_id}",
- "status_code": 404,
- "error_code": "SUBSCRIPTION_NOT_FOUND",
- "details": {"subscription_id": subscription_id},
- }
-
- def test_message_includes_id(self):
- exc = self._create_not_found_exception("sub-123")
- assert "sub-123" in exc["message"]
-
- def test_status_code_404(self):
- exc = self._create_not_found_exception("sub-123")
- assert exc["status_code"] == 404
-
- def test_details_include_subscription_id(self):
- exc = self._create_not_found_exception("sub-456")
- assert exc["details"]["subscription_id"] == "sub-456"
-
-
-# --- SubscriptionCreationException ---
-
-
-class TestSubscriptionCreationException:
- """Tests for SubscriptionCreationException."""
-
- def _create_creation_exception(self, message, details=None):
- return {
- "message": f"Failed to create subscription: {message}",
- "status_code": 500,
- "error_code": "SUBSCRIPTION_CREATE_FAILED",
- "details": details or {},
- }
-
- def test_message_prefix(self):
- exc = self._create_creation_exception("Database error")
- assert exc["message"].startswith("Failed to create subscription:")
-
- def test_status_code_500(self):
- exc = self._create_creation_exception("Error")
- assert exc["status_code"] == 500
-
- def test_error_code(self):
- exc = self._create_creation_exception("Error")
- assert exc["error_code"] == "SUBSCRIPTION_CREATE_FAILED"
-
-
-# --- SubscriptionUpdateException ---
-
-
-class TestSubscriptionUpdateException:
- """Tests for SubscriptionUpdateException."""
-
- def _create_update_exception(self, subscription_id, message):
- return {
- "message": f"Failed to update subscription {subscription_id}: {message}",
- "status_code": 500,
- "error_code": "SUBSCRIPTION_UPDATE_FAILED",
- "details": {"subscription_id": subscription_id},
- }
-
- def test_message_includes_id(self):
- exc = self._create_update_exception("sub-123", "Error")
- assert "sub-123" in exc["message"]
-
- def test_message_includes_error(self):
- exc = self._create_update_exception("sub-123", "Validation failed")
- assert "Validation failed" in exc["message"]
-
-
-# --- SubscriptionDeletionException ---
-
-
-class TestSubscriptionDeletionException:
- """Tests for SubscriptionDeletionException."""
-
- def _create_deletion_exception(self, subscription_id, message):
- return {
- "message": f"Failed to delete subscription {subscription_id}: {message}",
- "status_code": 500,
- "error_code": "SUBSCRIPTION_DELETE_FAILED",
- "details": {"subscription_id": subscription_id},
- }
-
- def test_message_format(self):
- exc = self._create_deletion_exception("sub-123", "Not found")
- assert "delete subscription sub-123" in exc["message"]
-
- def test_error_code(self):
- exc = self._create_deletion_exception("sub-123", "Error")
- assert exc["error_code"] == "SUBSCRIPTION_DELETE_FAILED"
-
-
-# --- DatabaseAccessException ---
-
-
-class TestDatabaseAccessException:
- """Tests for DatabaseAccessException."""
-
- def _create_db_exception(self, operation, message):
- return {
- "message": f"Database error during {operation}: {message}",
- "status_code": 500,
- "error_code": "DATABASE_ERROR",
- "details": {"operation": operation},
- }
-
- def test_message_includes_operation(self):
- exc = self._create_db_exception("insert", "Connection failed")
- assert "insert" in exc["message"]
-
- def test_details_include_operation(self):
- exc = self._create_db_exception("query", "Timeout")
- assert exc["details"]["operation"] == "query"
-
- def test_error_code(self):
- exc = self._create_db_exception("delete", "Error")
- assert exc["error_code"] == "DATABASE_ERROR"
-
-
-# --- NewsFeedGenerationException ---
-
-
-class TestNewsFeedGenerationException:
- """Tests for NewsFeedGenerationException."""
-
- def _create_feed_exception(self, message, user_id=None):
- details = {}
- if user_id:
- details["user_id"] = user_id
- return {
- "message": f"Failed to generate news feed: {message}",
- "status_code": 500,
- "error_code": "FEED_GENERATION_FAILED",
- "details": details,
- }
-
- def test_message_prefix(self):
- exc = self._create_feed_exception("Error")
- assert exc["message"].startswith("Failed to generate news feed:")
-
- def test_details_include_user_id_when_provided(self):
- exc = self._create_feed_exception("Error", user_id="user-123")
- assert exc["details"]["user_id"] == "user-123"
-
- def test_details_empty_when_no_user_id(self):
- exc = self._create_feed_exception("Error")
- assert exc["details"] == {}
-
-
-# --- ResearchProcessingException ---
-
-
-class TestResearchProcessingException:
- """Tests for ResearchProcessingException."""
-
- def _create_research_exception(self, message, research_id=None):
- details = {}
- if research_id:
- details["research_id"] = research_id
- return {
- "message": f"Failed to process research item: {message}",
- "status_code": 500,
- "error_code": "RESEARCH_PROCESSING_FAILED",
- "details": details,
- }
-
- def test_message_prefix(self):
- exc = self._create_research_exception("Parse error")
- assert exc["message"].startswith("Failed to process research item:")
-
- def test_details_include_research_id(self):
- exc = self._create_research_exception("Error", research_id="r-123")
- assert exc["details"]["research_id"] == "r-123"
-
-
-# --- NotImplementedException ---
-
-
-class TestNotImplementedException:
- """Tests for NotImplementedException."""
-
- def _create_not_implemented(self, feature):
- return {
- "message": f"Feature not yet implemented: {feature}",
- "status_code": 501,
- "error_code": "NOT_IMPLEMENTED",
- "details": {"feature": feature},
- }
-
- def test_status_code_501(self):
- exc = self._create_not_implemented("Advanced search")
- assert exc["status_code"] == 501
-
- def test_details_include_feature(self):
- exc = self._create_not_implemented("Real-time updates")
- assert exc["details"]["feature"] == "Real-time updates"
-
-
-# --- InvalidParameterException ---
-
-
-class TestInvalidParameterException:
- """Tests for InvalidParameterException."""
-
- def _create_invalid_param(self, parameter, value, message):
- return {
- "message": f"Invalid parameter '{parameter}': {message}",
- "status_code": 400,
- "error_code": "INVALID_PARAMETER",
- "details": {"parameter": parameter, "value": value},
- }
-
- def test_message_includes_parameter(self):
- exc = self._create_invalid_param("limit", -1, "Must be positive")
- assert "limit" in exc["message"]
-
- def test_status_code_400(self):
- exc = self._create_invalid_param("p", "v", "m")
- assert exc["status_code"] == 400
-
- def test_details_include_value(self):
- exc = self._create_invalid_param("sort", "invalid", "Not a valid sort")
- assert exc["details"]["value"] == "invalid"
-
-
-# --- SchedulerNotificationException ---
-
-
-class TestSchedulerNotificationException:
- """Tests for SchedulerNotificationException."""
-
- def _create_scheduler_exception(self, action, message):
- return {
- "message": f"Failed to notify scheduler about {action}: {message}",
- "status_code": 500,
- "error_code": "SCHEDULER_NOTIFICATION_FAILED",
- "details": {"action": action},
- }
-
- def test_message_includes_action(self):
- exc = self._create_scheduler_exception("subscription update", "Timeout")
- assert "subscription update" in exc["message"]
-
- def test_details_include_action(self):
- exc = self._create_scheduler_exception("job removal", "Error")
- assert exc["details"]["action"] == "job removal"
-
-
-# --- Status code patterns ---
-
-
-class TestStatusCodePatterns:
- """Tests for HTTP status code patterns."""
-
- def test_400_is_client_error(self):
- assert 400 // 100 == 4
-
- def test_404_is_not_found(self):
- assert 404 == 404
-
- def test_500_is_server_error(self):
- assert 500 // 100 == 5
-
- def test_501_is_not_implemented(self):
- assert 501 == 501
-
- def test_503_is_service_unavailable(self):
- assert 503 == 503
-
-
-# --- Error code naming patterns ---
-
-
-class TestErrorCodeNamingPatterns:
- """Tests for error code naming conventions."""
-
- def test_uppercase_with_underscores(self):
- error_codes = [
- "NEWS_DISABLED",
- "INVALID_LIMIT",
- "SUBSCRIPTION_NOT_FOUND",
- "DATABASE_ERROR",
- ]
- for code in error_codes:
- assert code == code.upper()
- assert " " not in code
diff --git a/tests/news/test_folder_manager_logic_behavior.py b/tests/news/test_folder_manager_logic_behavior.py
deleted file mode 100644
index 1b8de52359..0000000000
--- a/tests/news/test_folder_manager_logic_behavior.py
+++ /dev/null
@@ -1,433 +0,0 @@
-"""
-Deep behavioral tests for folder_manager.py pure logic.
-Tests folder update validation, subscription organization,
-next_refresh recalculation, and stats aggregation.
-"""
-
-from datetime import datetime, timedelta, timezone
-
-
-# --- Update folder field validation ---
-
-
-class TestUpdateFolderFieldValidation:
- """Tests for folder update field validation."""
-
- PROTECTED_FIELDS = {"id", "created_at"}
-
- def _is_updateable(self, field):
- return field not in self.PROTECTED_FIELDS
-
- def test_name_updateable(self):
- assert self._is_updateable("name") is True
-
- def test_description_updateable(self):
- assert self._is_updateable("description") is True
-
- def test_id_not_updateable(self):
- assert self._is_updateable("id") is False
-
- def test_created_at_not_updateable(self):
- assert self._is_updateable("created_at") is False
-
- def test_updated_at_updateable(self):
- assert self._is_updateable("updated_at") is True
-
-
-class TestFilterUpdateKwargs:
- """Tests for filtering kwargs to valid fields."""
-
- PROTECTED = {"id", "created_at"}
-
- def _filter_kwargs(self, kwargs):
- return {k: v for k, v in kwargs.items() if k not in self.PROTECTED}
-
- def test_filters_id(self):
- result = self._filter_kwargs({"name": "New", "id": "should-not-update"})
- assert "id" not in result
- assert result["name"] == "New"
-
- def test_filters_created_at(self):
- result = self._filter_kwargs({"created_at": "2025-01-01"})
- assert "created_at" not in result
-
- def test_preserves_valid_fields(self):
- result = self._filter_kwargs({"name": "X", "description": "Y"})
- assert result == {"name": "X", "description": "Y"}
-
- def test_empty_after_filter(self):
- result = self._filter_kwargs({"id": "1", "created_at": "X"})
- assert result == {}
-
-
-# --- Subscription update field validation ---
-
-
-class TestSubscriptionUpdateFieldValidation:
- """Tests for subscription update field validation."""
-
- PROTECTED = {"id", "created_at"}
-
- def _is_updateable(self, field):
- return field not in self.PROTECTED
-
- def test_folder_updateable(self):
- assert self._is_updateable("folder") is True
-
- def test_refresh_interval_updateable(self):
- assert self._is_updateable("refresh_interval_minutes") is True
-
- def test_status_updateable(self):
- assert self._is_updateable("status") is True
-
- def test_id_not_updateable(self):
- assert self._is_updateable("id") is False
-
- def test_created_at_not_updateable(self):
- assert self._is_updateable("created_at") is False
-
-
-# --- Next refresh recalculation ---
-
-
-class TestNextRefreshRecalculation:
- """Tests for next_refresh recalculation on interval change."""
-
- def _should_recalc(self, kwargs):
- return "refresh_interval_minutes" in kwargs
-
- def test_interval_change_needs_recalc(self):
- assert self._should_recalc({"refresh_interval_minutes": 120}) is True
-
- def test_name_change_no_recalc(self):
- assert self._should_recalc({"name": "New Name"}) is False
-
- def test_folder_change_no_recalc(self):
- assert self._should_recalc({"folder": "News"}) is False
-
-
-class TestNextRefreshFromLastRefresh:
- """Tests for calculating next_refresh from last_refresh."""
-
- def _calc_next(self, last_refresh, interval_minutes):
- if last_refresh:
- return last_refresh + timedelta(minutes=interval_minutes)
- return datetime.now(timezone.utc) + timedelta(minutes=interval_minutes)
-
- def test_with_last_refresh(self):
- last = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- result = self._calc_next(last, 60)
- assert result == datetime(2025, 6, 15, 11, 0, tzinfo=timezone.utc)
-
- def test_without_last_refresh(self):
- before = datetime.now(timezone.utc)
- result = self._calc_next(None, 60)
- after = datetime.now(timezone.utc)
- expected_min = before + timedelta(minutes=60)
- expected_max = after + timedelta(minutes=60)
- assert expected_min <= result <= expected_max
-
-
-# --- Delete folder subscription handling ---
-
-
-class TestDeleteFolderSubscriptionHandling:
- """Tests for handling subscriptions when deleting folder."""
-
- def _get_move_target(self, move_to):
- if move_to:
- return move_to
- return None
-
- def test_move_to_target(self):
- assert self._get_move_target("Archive") == "Archive"
-
- def test_no_target_is_none(self):
- assert self._get_move_target(None) is None
-
- def test_empty_string_target(self):
- # Empty string is falsy
- assert self._get_move_target("") is None
-
-
-# --- Subscriptions by folder organization ---
-
-
-class TestSubscriptionsByFolderOrganization:
- """Tests for organizing subscriptions by folder."""
-
- def _build_result_structure(self):
- return {"folders": [], "uncategorized": []}
-
- def test_initial_structure(self):
- result = self._build_result_structure()
- assert result["folders"] == []
- assert result["uncategorized"] == []
-
- def test_folders_is_list(self):
- result = self._build_result_structure()
- assert isinstance(result["folders"], list)
-
- def test_uncategorized_is_list(self):
- result = self._build_result_structure()
- assert isinstance(result["uncategorized"], list)
-
-
-class TestFolderEntryStructure:
- """Tests for folder entry structure in result."""
-
- def _build_folder_entry(self, folder_dict, subscriptions):
- return {
- "folder": folder_dict,
- "subscriptions": subscriptions,
- }
-
- def test_has_folder(self):
- result = self._build_folder_entry({"id": "f1", "name": "News"}, [])
- assert result["folder"]["name"] == "News"
-
- def test_has_subscriptions(self):
- subs = [{"id": "s1"}, {"id": "s2"}]
- result = self._build_folder_entry({}, subs)
- assert len(result["subscriptions"]) == 2
-
-
-# --- Subscription dict mapping ---
-
-
-class TestSubscriptionDictMapping:
- """Tests for _sub_to_dict mapping."""
-
- def _sub_to_dict(self, sub_dict):
- return {
- "id": sub_dict.get("id"),
- "type": sub_dict.get("subscription_type"),
- "query_or_topic": sub_dict.get("query_or_topic"),
- "created_at": sub_dict.get("created_at"),
- "last_refresh": sub_dict.get("last_refresh"),
- "next_refresh": sub_dict.get("next_refresh"),
- "refresh_interval_minutes": sub_dict.get(
- "refresh_interval_minutes"
- ),
- "status": sub_dict.get("status"),
- }
-
- def test_maps_id(self):
- result = self._sub_to_dict({"id": "s123"})
- assert result["id"] == "s123"
-
- def test_maps_type(self):
- result = self._sub_to_dict({"subscription_type": "search"})
- assert result["type"] == "search"
-
- def test_maps_query(self):
- result = self._sub_to_dict({"query_or_topic": "AI news"})
- assert result["query_or_topic"] == "AI news"
-
- def test_maps_interval(self):
- result = self._sub_to_dict({"refresh_interval_minutes": 60})
- assert result["refresh_interval_minutes"] == 60
-
- def test_maps_status(self):
- result = self._sub_to_dict({"status": "active"})
- assert result["status"] == "active"
-
- def test_missing_fields_none(self):
- result = self._sub_to_dict({})
- assert result["id"] is None
- assert result["type"] is None
-
-
-# --- Isoformat datetime handling ---
-
-
-class TestIsoformatDatetimeHandling:
- """Tests for datetime isoformat conversion patterns."""
-
- def _to_iso_or_none(self, dt):
- return dt.isoformat() if dt else None
-
- def test_datetime_to_iso(self):
- dt = datetime(2025, 6, 15, 10, 30, 0, tzinfo=timezone.utc)
- result = self._to_iso_or_none(dt)
- assert "2025-06-15" in result
- assert "10:30:00" in result
-
- def test_none_datetime(self):
- assert self._to_iso_or_none(None) is None
-
-
-# --- Subscription stats aggregation ---
-
-
-class TestSubscriptionStatsAggregation:
- """Tests for subscription statistics calculation."""
-
- def _calc_stats(self, total, active, by_type, folder_count):
- return {
- "total": total,
- "active": active,
- "by_type": by_type,
- "folders": folder_count,
- }
-
- def test_basic_stats(self):
- result = self._calc_stats(10, 8, {"search": 5, "topic": 3}, 2)
- assert result["total"] == 10
- assert result["active"] == 8
- assert result["by_type"]["search"] == 5
- assert result["folders"] == 2
-
- def test_no_subscriptions(self):
- result = self._calc_stats(0, 0, {"search": 0, "topic": 0}, 0)
- assert result["total"] == 0
- assert result["active"] == 0
-
- def test_all_active(self):
- result = self._calc_stats(5, 5, {}, 1)
- assert result["total"] == result["active"]
-
-
-# --- Type counting ---
-
-
-class TestTypeCountingPatterns:
- """Tests for subscription type counting."""
-
- def _count_by_type(self, subscriptions):
- counts = {"search": 0, "topic": 0}
- for sub in subscriptions:
- sub_type = sub.get("subscription_type")
- if sub_type in counts:
- counts[sub_type] += 1
- return counts
-
- def test_count_search(self):
- subs = [
- {"subscription_type": "search"},
- {"subscription_type": "search"},
- ]
- result = self._count_by_type(subs)
- assert result["search"] == 2
-
- def test_count_topic(self):
- subs = [{"subscription_type": "topic"}]
- result = self._count_by_type(subs)
- assert result["topic"] == 1
-
- def test_count_mixed(self):
- subs = [
- {"subscription_type": "search"},
- {"subscription_type": "topic"},
- {"subscription_type": "search"},
- ]
- result = self._count_by_type(subs)
- assert result["search"] == 2
- assert result["topic"] == 1
-
- def test_count_empty(self):
- result = self._count_by_type([])
- assert result["search"] == 0
- assert result["topic"] == 0
-
- def test_unknown_type_ignored(self):
- subs = [{"subscription_type": "unknown"}]
- result = self._count_by_type(subs)
- assert result["search"] == 0
- assert result["topic"] == 0
-
-
-# --- Active status filter ---
-
-
-class TestActiveStatusFilter:
- """Tests for filtering active subscriptions."""
-
- def _is_active(self, sub):
- return sub.get("status") == "active"
-
- def test_active_status(self):
- assert self._is_active({"status": "active"}) is True
-
- def test_paused_status(self):
- assert self._is_active({"status": "paused"}) is False
-
- def test_expired_status(self):
- assert self._is_active({"status": "expired"}) is False
-
- def test_no_status(self):
- assert self._is_active({}) is False
-
-
-# --- Folder filter by name ---
-
-
-class TestFolderFilterByName:
- """Tests for filtering subscriptions by folder name."""
-
- def _matches_folder(self, sub, folder_name):
- return sub.get("folder") == folder_name
-
- def test_matching_folder(self):
- sub = {"folder": "News"}
- assert self._matches_folder(sub, "News") is True
-
- def test_different_folder(self):
- sub = {"folder": "Tech"}
- assert self._matches_folder(sub, "News") is False
-
- def test_no_folder(self):
- sub = {}
- assert self._matches_folder(sub, "News") is False
-
- def test_none_folder(self):
- sub = {"folder": None}
- assert self._matches_folder(sub, None) is True
-
-
-# --- Uncategorized filter ---
-
-
-class TestUncategorizedFilter:
- """Tests for filtering uncategorized subscriptions."""
-
- def _is_uncategorized(self, sub):
- return sub.get("folder") is None
-
- def test_no_folder(self):
- assert self._is_uncategorized({}) is True
-
- def test_none_folder(self):
- assert self._is_uncategorized({"folder": None}) is True
-
- def test_has_folder(self):
- assert self._is_uncategorized({"folder": "News"}) is False
-
- def test_empty_string_folder(self):
- # Empty string is not None
- assert self._is_uncategorized({"folder": ""}) is False
-
-
-# --- Folder to dict ---
-
-
-class TestFolderToDict:
- """Tests for folder dict structure."""
-
- def _folder_dict_fields(self):
- return ["id", "name", "description", "created_at", "updated_at"]
-
- def test_has_id(self):
- assert "id" in self._folder_dict_fields()
-
- def test_has_name(self):
- assert "name" in self._folder_dict_fields()
-
- def test_has_description(self):
- assert "description" in self._folder_dict_fields()
-
- def test_has_created_at(self):
- assert "created_at" in self._folder_dict_fields()
-
- def test_has_updated_at(self):
- assert "updated_at" in self._folder_dict_fields()
diff --git a/tests/news/test_logging_patterns_behavior.py b/tests/news/test_logging_patterns_behavior.py
deleted file mode 100644
index 044c37a0b8..0000000000
--- a/tests/news/test_logging_patterns_behavior.py
+++ /dev/null
@@ -1,1011 +0,0 @@
-"""
-Behavioral tests for logging patterns.
-
-These tests verify the logic of logging patterns like log formatting,
-level filtering, context management, and structured logging
-without making actual log writes.
-"""
-
-import json
-import re
-import time
-from dataclasses import dataclass
-from datetime import datetime
-from enum import IntEnum
-
-
-class LogLevel(IntEnum):
- """Log levels in order of severity."""
-
- DEBUG = 10
- INFO = 20
- WARNING = 30
- ERROR = 40
- CRITICAL = 50
-
-
-class TestLogLevelFiltering:
- """Tests for log level filtering."""
-
- def test_should_log_at_level(self):
- """Test log level filtering logic."""
-
- def should_log(message_level, configured_level):
- return message_level >= configured_level
-
- assert should_log(LogLevel.ERROR, LogLevel.INFO) is True
- assert should_log(LogLevel.DEBUG, LogLevel.INFO) is False
- assert should_log(LogLevel.INFO, LogLevel.INFO) is True
-
- def test_parse_log_level(self):
- """Test parsing log level from string."""
-
- def parse_level(level_string):
- levels = {
- "debug": LogLevel.DEBUG,
- "info": LogLevel.INFO,
- "warning": LogLevel.WARNING,
- "warn": LogLevel.WARNING,
- "error": LogLevel.ERROR,
- "critical": LogLevel.CRITICAL,
- }
- return levels.get(level_string.lower(), LogLevel.INFO)
-
- assert parse_level("DEBUG") == LogLevel.DEBUG
- assert parse_level("warning") == LogLevel.WARNING
- assert parse_level("unknown") == LogLevel.INFO
-
- def test_level_name_conversion(self):
- """Test converting level to name."""
-
- def level_name(level):
- names = {
- LogLevel.DEBUG: "DEBUG",
- LogLevel.INFO: "INFO",
- LogLevel.WARNING: "WARNING",
- LogLevel.ERROR: "ERROR",
- LogLevel.CRITICAL: "CRITICAL",
- }
- return names.get(level, "UNKNOWN")
-
- assert level_name(LogLevel.DEBUG) == "DEBUG"
- assert level_name(LogLevel.ERROR) == "ERROR"
-
- def test_environment_based_level(self):
- """Test determining log level from environment."""
-
- def get_level_for_env(env):
- env_levels = {
- "development": LogLevel.DEBUG,
- "testing": LogLevel.DEBUG,
- "staging": LogLevel.INFO,
- "production": LogLevel.WARNING,
- }
- return env_levels.get(env, LogLevel.INFO)
-
- assert get_level_for_env("development") == LogLevel.DEBUG
- assert get_level_for_env("production") == LogLevel.WARNING
-
- def test_module_specific_level(self):
- """Test module-specific log levels."""
-
- def get_effective_level(module, module_levels, default_level):
- # Check for exact match
- if module in module_levels:
- return module_levels[module]
- # Check for parent modules
- parts = module.split(".")
- for i in range(len(parts) - 1, 0, -1):
- parent = ".".join(parts[:i])
- if parent in module_levels:
- return module_levels[parent]
- return default_level
-
- levels = {
- "myapp": LogLevel.INFO,
- "myapp.db": LogLevel.DEBUG,
- }
- assert (
- get_effective_level("myapp.db.query", levels, LogLevel.WARNING)
- == LogLevel.DEBUG
- )
- assert (
- get_effective_level("myapp.api", levels, LogLevel.WARNING)
- == LogLevel.INFO
- )
- assert (
- get_effective_level("other", levels, LogLevel.WARNING)
- == LogLevel.WARNING
- )
-
-
-class TestLogFormatting:
- """Tests for log message formatting."""
-
- def test_basic_format(self):
- """Test basic log message format."""
-
- def format_log(level, message, timestamp=None):
- if timestamp is None:
- timestamp = datetime.now().isoformat()
- level_name = LogLevel(level).name
- return f"{timestamp} [{level_name}] {message}"
-
- log = format_log(
- LogLevel.INFO, "Application started", "2024-01-01T12:00:00"
- )
- assert log == "2024-01-01T12:00:00 [INFO] Application started"
-
- def test_format_with_context(self):
- """Test formatting with context fields."""
-
- def format_with_context(level, message, context):
- level_name = LogLevel(level).name
- context_str = " ".join(f"{k}={v}" for k, v in context.items())
- return f"[{level_name}] {message} | {context_str}"
-
- log = format_with_context(
- LogLevel.INFO,
- "User logged in",
- {"user_id": "123", "ip": "192.168.1.1"},
- )
- assert "[INFO]" in log
- assert "User logged in" in log
- assert "user_id=123" in log
-
- def test_json_format(self):
- """Test JSON log formatting."""
-
- def format_json(level, message, **extra):
- record = {
- "timestamp": "2024-01-01T12:00:00",
- "level": LogLevel(level).name,
- "message": message,
- **extra,
- }
- return json.dumps(record)
-
- log = format_json(LogLevel.ERROR, "Failed to connect", error_code=500)
- parsed = json.loads(log)
- assert parsed["level"] == "ERROR"
- assert parsed["message"] == "Failed to connect"
- assert parsed["error_code"] == 500
-
- def test_format_exception(self):
- """Test formatting exception in log."""
-
- def format_exception(exc):
- return {
- "type": type(exc).__name__,
- "message": str(exc),
- "module": type(exc).__module__,
- }
-
- try:
- raise ValueError("Invalid value")
- except ValueError as e:
- formatted = format_exception(e)
- assert formatted["type"] == "ValueError"
- assert formatted["message"] == "Invalid value"
-
- def test_truncate_long_message(self):
- """Test truncating long messages."""
-
- def truncate_message(message, max_length=1000):
- if len(message) <= max_length:
- return message
- return message[: max_length - 3] + "..."
-
- short = "Short message"
- assert truncate_message(short) == short
-
- long = "x" * 2000
- truncated = truncate_message(long, max_length=100)
- assert len(truncated) == 100
- assert truncated.endswith("...")
-
-
-class TestStructuredLogging:
- """Tests for structured logging patterns."""
-
- def test_create_log_record(self):
- """Test creating structured log record."""
-
- @dataclass
- class LogRecord:
- timestamp: str
- level: str
- message: str
- logger: str
- extra: dict
-
- def create_record(level, message, logger="root", **extra):
- return LogRecord(
- timestamp=datetime.now().isoformat(),
- level=LogLevel(level).name,
- message=message,
- logger=logger,
- extra=extra,
- )
-
- record = create_record(LogLevel.INFO, "Test message", user_id="123")
- assert record.level == "INFO"
- assert record.message == "Test message"
- assert record.extra["user_id"] == "123"
-
- def test_add_common_fields(self):
- """Test adding common fields to log records."""
-
- def add_common_fields(record, common_fields):
- result = record.copy()
- for key, value in common_fields.items():
- if key not in result:
- result[key] = value
- return result
-
- record = {"message": "Test", "level": "INFO"}
- common = {"service": "api", "environment": "prod", "version": "1.0.0"}
- enhanced = add_common_fields(record, common)
- assert enhanced["service"] == "api"
- assert enhanced["environment"] == "prod"
-
- def test_flatten_nested_context(self):
- """Test flattening nested context for logging."""
-
- def flatten_context(context, prefix="", separator="."):
- flat = {}
- for key, value in context.items():
- full_key = f"{prefix}{separator}{key}" if prefix else key
- if isinstance(value, dict):
- flat.update(flatten_context(value, full_key, separator))
- else:
- flat[full_key] = value
- return flat
-
- nested = {
- "user": {"id": 123, "name": "John"},
- "request": {"method": "GET", "path": "/api"},
- }
- flat = flatten_context(nested)
- assert flat["user.id"] == 123
- assert flat["user.name"] == "John"
- assert flat["request.method"] == "GET"
-
- def test_serialize_log_value(self):
- """Test serializing log values."""
-
- def serialize_value(value):
- if isinstance(value, datetime):
- return value.isoformat()
- if isinstance(value, (set, frozenset)):
- return list(value)
- if isinstance(value, bytes):
- return value.decode("utf-8", errors="replace")
- if hasattr(value, "__dict__"):
- return str(value)
- return value
-
- assert serialize_value(datetime(2024, 1, 1)) == "2024-01-01T00:00:00"
- assert serialize_value({1, 2, 3}) == [1, 2, 3]
- assert serialize_value(b"bytes") == "bytes"
-
- def test_mask_sensitive_values(self):
- """Test masking sensitive values in logs."""
-
- def mask_sensitive(record, sensitive_keys=None):
- if sensitive_keys is None:
- sensitive_keys = {
- "password",
- "token",
- "secret",
- "api_key",
- "credit_card",
- }
- result = {}
- for key, value in record.items():
- if key.lower() in sensitive_keys:
- result[key] = "***MASKED***"
- elif isinstance(value, dict):
- result[key] = mask_sensitive(value, sensitive_keys)
- else:
- result[key] = value
- return result
-
- record = {
- "user": "john",
- "password": "secret123",
- "data": {"api_key": "abc123"},
- }
- masked = mask_sensitive(record)
- assert masked["user"] == "john"
- assert masked["password"] == "***MASKED***"
- assert masked["data"]["api_key"] == "***MASKED***"
-
-
-class TestLogContext:
- """Tests for log context management."""
-
- def test_context_manager(self):
- """Test log context as a stack."""
-
- class LogContext:
- def __init__(self):
- self._stack = [{}]
-
- def push(self, **kwargs):
- new_context = {**self._stack[-1], **kwargs}
- self._stack.append(new_context)
-
- def pop(self):
- if len(self._stack) > 1:
- return self._stack.pop()
- return None
-
- def get(self):
- return self._stack[-1].copy()
-
- ctx = LogContext()
- ctx.push(request_id="123")
- assert ctx.get()["request_id"] == "123"
-
- ctx.push(user_id="456")
- assert ctx.get()["request_id"] == "123"
- assert ctx.get()["user_id"] == "456"
-
- ctx.pop()
- assert "user_id" not in ctx.get()
- assert ctx.get()["request_id"] == "123"
-
- def test_bind_context(self):
- """Test binding context to logger."""
-
- def bind_context(existing_context, **new_context):
- return {**existing_context, **new_context}
-
- ctx = {"service": "api"}
- ctx = bind_context(ctx, request_id="123")
- ctx = bind_context(ctx, user_id="456")
- assert ctx["service"] == "api"
- assert ctx["request_id"] == "123"
- assert ctx["user_id"] == "456"
-
- def test_unbind_context(self):
- """Test unbinding context from logger."""
-
- def unbind_context(context, *keys):
- return {k: v for k, v in context.items() if k not in keys}
-
- ctx = {"service": "api", "request_id": "123", "user_id": "456"}
- ctx = unbind_context(ctx, "user_id", "request_id")
- assert ctx == {"service": "api"}
-
- def test_clear_context(self):
- """Test clearing all context."""
-
- def clear_context(context, preserve_keys=None):
- if preserve_keys is None:
- return {}
- return {k: v for k, v in context.items() if k in preserve_keys}
-
- ctx = {"service": "api", "request_id": "123", "user_id": "456"}
- assert clear_context(ctx) == {}
- assert clear_context(ctx, preserve_keys={"service"}) == {
- "service": "api"
- }
-
- def test_context_inheritance(self):
- """Test context inheritance for child loggers."""
-
- def create_child_context(parent_context, child_name):
- return {
- **parent_context,
- "logger": f"{parent_context.get('logger', 'root')}.{child_name}",
- }
-
- parent = {"service": "api", "logger": "app"}
- child = create_child_context(parent, "db")
- assert child["service"] == "api"
- assert child["logger"] == "app.db"
-
-
-class TestLogFiltering:
- """Tests for log filtering patterns."""
-
- def test_filter_by_pattern(self):
- """Test filtering logs by message pattern."""
-
- def matches_filter(
- message, include_patterns=None, exclude_patterns=None
- ):
- if exclude_patterns:
- for pattern in exclude_patterns:
- if re.search(pattern, message):
- return False
- if include_patterns:
- for pattern in include_patterns:
- if re.search(pattern, message):
- return True
- return False
- return True
-
- assert matches_filter("User login successful") is True
- assert (
- matches_filter("Healthcheck OK", exclude_patterns=[r"Healthcheck"])
- is False
- )
- assert (
- matches_filter(
- "Error in payment", include_patterns=[r"Error", r"Warning"]
- )
- is True
- )
- assert (
- matches_filter(
- "Info message", include_patterns=[r"Error", r"Warning"]
- )
- is False
- )
-
- def test_filter_by_rate(self):
- """Test rate-limited log filtering."""
-
- class RateLimitedFilter:
- def __init__(self, rate_seconds=60):
- self.rate_seconds = rate_seconds
- self.last_log_times = {}
-
- def should_log(self, key):
- now = time.time()
- last_time = self.last_log_times.get(key, 0)
- if now - last_time >= self.rate_seconds:
- self.last_log_times[key] = now
- return True
- return False
-
- f = RateLimitedFilter(rate_seconds=60)
- assert f.should_log("error_type_1") is True
- assert f.should_log("error_type_1") is False # Too soon
- assert f.should_log("error_type_2") is True # Different key
-
- def test_filter_by_sampling(self):
- """Test sampling filter for high-volume logs."""
-
- def should_sample(sample_rate):
- import random
-
- return random.random() < sample_rate
-
- # With 100% sample rate, always log
- # Can't test randomness deterministically, but can test edge cases
-
- def sample_decision(sample_rate, random_value):
- return random_value < sample_rate
-
- assert sample_decision(1.0, 0.5) is True # 100% rate
- assert sample_decision(0.0, 0.5) is False # 0% rate
- assert sample_decision(0.5, 0.3) is True # Under threshold
- assert sample_decision(0.5, 0.7) is False # Over threshold
-
- def test_deduplicate_filter(self):
- """Test deduplication filter for repeated messages."""
-
- class DeduplicateFilter:
- def __init__(self, window_seconds=60, max_duplicates=3):
- self.window_seconds = window_seconds
- self.max_duplicates = max_duplicates
- self.message_counts = {}
-
- def should_log(self, message_key):
- now = time.time()
- if message_key not in self.message_counts:
- self.message_counts[message_key] = {
- "count": 1,
- "first_seen": now,
- }
- return True
-
- data = self.message_counts[message_key]
- if now - data["first_seen"] > self.window_seconds:
- # Reset window
- self.message_counts[message_key] = {
- "count": 1,
- "first_seen": now,
- }
- return True
-
- data["count"] += 1
- return data["count"] <= self.max_duplicates
-
- f = DeduplicateFilter(max_duplicates=3)
- assert f.should_log("error_1") is True
- assert f.should_log("error_1") is True
- assert f.should_log("error_1") is True
- assert f.should_log("error_1") is False # Exceeded max
-
- def test_context_filter(self):
- """Test filtering by context fields."""
-
- def context_matches(log_context, required_context):
- for key, value in required_context.items():
- if key not in log_context:
- return False
- if callable(value):
- if not value(log_context[key]):
- return False
- elif log_context[key] != value:
- return False
- return True
-
- log = {"service": "api", "user_id": "123", "status": 500}
- assert context_matches(log, {"service": "api"}) is True
- assert context_matches(log, {"service": "web"}) is False
- assert context_matches(log, {"status": lambda x: x >= 400}) is True
-
-
-class TestLogOutput:
- """Tests for log output handling."""
-
- def test_select_output_by_level(self):
- """Test selecting output destination by level."""
-
- def get_output(level):
- if level >= LogLevel.ERROR:
- return "stderr"
- return "stdout"
-
- assert get_output(LogLevel.DEBUG) == "stdout"
- assert get_output(LogLevel.INFO) == "stdout"
- assert get_output(LogLevel.ERROR) == "stderr"
- assert get_output(LogLevel.CRITICAL) == "stderr"
-
- def test_format_for_console(self):
- """Test console-friendly formatting."""
-
- def format_console(level, message, use_color=True):
- colors = {
- LogLevel.DEBUG: "\033[90m", # Gray
- LogLevel.INFO: "\033[0m", # Default
- LogLevel.WARNING: "\033[33m", # Yellow
- LogLevel.ERROR: "\033[31m", # Red
- LogLevel.CRITICAL: "\033[1;31m", # Bold red
- }
- reset = "\033[0m"
-
- level_name = LogLevel(level).name
- if use_color:
- color = colors.get(level, "")
- return f"{color}[{level_name}] {message}{reset}"
- return f"[{level_name}] {message}"
-
- log = format_console(LogLevel.ERROR, "Error occurred", use_color=False)
- assert log == "[ERROR] Error occurred"
-
- colored = format_console(
- LogLevel.ERROR, "Error occurred", use_color=True
- )
- assert "\033[31m" in colored # Red color code
-
- def test_format_for_file(self):
- """Test file-friendly formatting."""
-
- def format_file(level, message, timestamp=None, include_pid=True):
- if timestamp is None:
- timestamp = datetime.now().isoformat()
- level_name = LogLevel(level).name
- pid_str = f" pid={12345}" if include_pid else ""
- return f"{timestamp}{pid_str} [{level_name}] {message}"
-
- log = format_file(LogLevel.INFO, "Test message", "2024-01-01T12:00:00")
- assert "2024-01-01T12:00:00" in log
- assert "pid=12345" in log
- assert "[INFO]" in log
-
- def test_format_for_json_lines(self):
- """Test JSON Lines formatting."""
-
- def format_jsonl(level, message, **extra):
- record = {
- "ts": time.time(),
- "level": LogLevel(level).name,
- "msg": message,
- **extra,
- }
- return json.dumps(record, default=str)
-
- log = format_jsonl(LogLevel.INFO, "Test", user="john")
- parsed = json.loads(log)
- assert parsed["level"] == "INFO"
- assert parsed["msg"] == "Test"
- assert parsed["user"] == "john"
-
- def test_batch_logs_for_output(self):
- """Test batching logs for efficient output."""
-
- def batch_logs(logs, batch_size=100, max_wait_ms=1000):
- batches = []
- current_batch = []
- for log in logs:
- current_batch.append(log)
- if len(current_batch) >= batch_size:
- batches.append(current_batch)
- current_batch = []
- if current_batch:
- batches.append(current_batch)
- return batches
-
- logs = [f"log_{i}" for i in range(250)]
- batches = batch_logs(logs, batch_size=100)
- assert len(batches) == 3
- assert len(batches[0]) == 100
- assert len(batches[2]) == 50
-
-
-class TestLogMetrics:
- """Tests for log-based metrics patterns."""
-
- def test_count_by_level(self):
- """Test counting logs by level."""
-
- class LogCounter:
- def __init__(self):
- self.counts = {level: 0 for level in LogLevel}
-
- def increment(self, level):
- self.counts[level] += 1
-
- def get_counts(self):
- return {LogLevel(k).name: v for k, v in self.counts.items()}
-
- counter = LogCounter()
- counter.increment(LogLevel.INFO)
- counter.increment(LogLevel.INFO)
- counter.increment(LogLevel.ERROR)
-
- counts = counter.get_counts()
- assert counts["INFO"] == 2
- assert counts["ERROR"] == 1
-
- def test_calculate_error_rate(self):
- """Test calculating error rate from log counts."""
-
- def calculate_error_rate(counts):
- total = sum(counts.values())
- if total == 0:
- return 0.0
- errors = counts.get(LogLevel.ERROR, 0) + counts.get(
- LogLevel.CRITICAL, 0
- )
- return errors / total
-
- counts = {
- LogLevel.INFO: 90,
- LogLevel.WARNING: 5,
- LogLevel.ERROR: 4,
- LogLevel.CRITICAL: 1,
- }
- rate = calculate_error_rate(counts)
- assert rate == 0.05 # 5% error rate
-
- def test_track_log_rate(self):
- """Test tracking log rate over time."""
-
- class LogRateTracker:
- def __init__(self, window_seconds=60):
- self.window_seconds = window_seconds
- self.timestamps = []
-
- def record(self):
- self.timestamps.append(time.time())
- self._cleanup()
-
- def _cleanup(self):
- cutoff = time.time() - self.window_seconds
- self.timestamps = [t for t in self.timestamps if t > cutoff]
-
- def rate_per_second(self):
- self._cleanup()
- if not self.timestamps:
- return 0.0
- return len(self.timestamps) / self.window_seconds
-
- tracker = LogRateTracker(window_seconds=60)
- for _ in range(120):
- tracker.record()
- assert tracker.rate_per_second() == 2.0
-
- def test_detect_anomaly(self):
- """Test detecting logging anomalies."""
-
- def is_anomalous(current_rate, baseline_rate, threshold_multiplier=3):
- if baseline_rate == 0:
- return current_rate > 0
- return current_rate > baseline_rate * threshold_multiplier
-
- assert is_anomalous(10, 100) is False # Normal
- assert is_anomalous(400, 100) is True # 4x baseline - anomalous
- assert is_anomalous(300, 100) is False # Exactly 3x - threshold
-
-
-class TestLogParsing:
- """Tests for log parsing patterns."""
-
- def test_parse_log_line(self):
- """Test parsing structured log line."""
-
- def parse_log_line(line):
- # Format: timestamp [LEVEL] message | key=value ...
- match = re.match(
- r"(\S+)\s+\[(\w+)\]\s+(.+?)(?:\s+\|\s+(.+))?$", line
- )
- if not match:
- return None
- timestamp, level, message, context_str = match.groups()
- context = {}
- if context_str:
- for part in context_str.split():
- if "=" in part:
- key, value = part.split("=", 1)
- context[key] = value
- return {
- "timestamp": timestamp,
- "level": level,
- "message": message,
- "context": context,
- }
-
- line = "2024-01-01T12:00:00 [INFO] User logged in | user_id=123 ip=192.168.1.1"
- parsed = parse_log_line(line)
- assert parsed["timestamp"] == "2024-01-01T12:00:00"
- assert parsed["level"] == "INFO"
- assert parsed["message"] == "User logged in"
- assert parsed["context"]["user_id"] == "123"
-
- def test_parse_json_log(self):
- """Test parsing JSON log."""
-
- def parse_json_log(line):
- try:
- return json.loads(line)
- except json.JSONDecodeError:
- return None
-
- line = '{"timestamp": "2024-01-01T12:00:00", "level": "INFO", "message": "Test"}'
- parsed = parse_json_log(line)
- assert parsed["level"] == "INFO"
- assert parsed["message"] == "Test"
-
- def test_extract_error_details(self):
- """Test extracting error details from log."""
-
- def extract_error_info(log_record):
- if log_record.get("level") not in ("ERROR", "CRITICAL"):
- return None
- return {
- "error_type": log_record.get("error_type", "unknown"),
- "error_message": log_record.get(
- "error_message", log_record.get("message")
- ),
- "stack_trace": log_record.get("stack_trace"),
- "timestamp": log_record.get("timestamp"),
- }
-
- log = {
- "level": "ERROR",
- "message": "Database connection failed",
- "error_type": "ConnectionError",
- "timestamp": "2024-01-01T12:00:00",
- }
- info = extract_error_info(log)
- assert info["error_type"] == "ConnectionError"
-
- def test_group_logs_by_request(self):
- """Test grouping logs by request ID."""
-
- def group_by_request(logs):
- groups = {}
- for log in logs:
- request_id = log.get("request_id", "unknown")
- if request_id not in groups:
- groups[request_id] = []
- groups[request_id].append(log)
- return groups
-
- logs = [
- {"request_id": "req1", "message": "Start"},
- {"request_id": "req2", "message": "Start"},
- {"request_id": "req1", "message": "End"},
- ]
- groups = group_by_request(logs)
- assert len(groups["req1"]) == 2
- assert len(groups["req2"]) == 1
-
- def test_extract_timing_from_logs(self):
- """Test extracting timing information from logs."""
-
- def extract_timing(logs, start_pattern, end_pattern):
- start_time = None
- end_time = None
- for log in logs:
- if start_pattern in log.get("message", ""):
- start_time = log.get("timestamp")
- if end_pattern in log.get("message", ""):
- end_time = log.get("timestamp")
- if start_time and end_time:
- # In real implementation, would parse timestamps
- return {"start": start_time, "end": end_time}
- return None
-
- logs = [
- {"message": "Request start", "timestamp": 1000},
- {"message": "Processing", "timestamp": 1050},
- {"message": "Request end", "timestamp": 1100},
- ]
- timing = extract_timing(logs, "Request start", "Request end")
- assert timing["start"] == 1000
- assert timing["end"] == 1100
-
-
-class TestLogRotation:
- """Tests for log rotation patterns."""
-
- def test_should_rotate_by_size(self):
- """Test size-based rotation decision."""
-
- def should_rotate_size(current_size, max_size):
- return current_size >= max_size
-
- assert should_rotate_size(1024 * 1024 * 9, 1024 * 1024 * 10) is False
- assert should_rotate_size(1024 * 1024 * 10, 1024 * 1024 * 10) is True
- assert should_rotate_size(1024 * 1024 * 11, 1024 * 1024 * 10) is True
-
- def test_should_rotate_by_time(self):
- """Test time-based rotation decision."""
-
- def should_rotate_time(last_rotation, rotation_interval):
- return time.time() - last_rotation >= rotation_interval
-
- now = time.time()
- # Less than interval - don't rotate
- assert should_rotate_time(now - 3000, 3600) is False
- # Past interval - rotate
- assert should_rotate_time(now - 4000, 3600) is True
-
- def test_generate_rotated_filename(self):
- """Test generating rotated log filename."""
-
- def generate_rotated_name(base_name, index=None, timestamp=None):
- if timestamp:
- return f"{base_name}.{timestamp}"
- if index is not None:
- return f"{base_name}.{index}"
- return f"{base_name}.1"
-
- assert generate_rotated_name("app.log", index=1) == "app.log.1"
- assert (
- generate_rotated_name("app.log", timestamp="2024-01-01")
- == "app.log.2024-01-01"
- )
-
- def test_calculate_files_to_delete(self):
- """Test calculating old files to delete."""
-
- def files_to_delete(existing_files, max_files):
- if len(existing_files) <= max_files:
- return []
- # Sort by modification time (oldest first)
- sorted_files = sorted(existing_files, key=lambda f: f["mtime"])
- return sorted_files[: len(existing_files) - max_files]
-
- files = [
- {"name": "log.1", "mtime": 1000},
- {"name": "log.2", "mtime": 2000},
- {"name": "log.3", "mtime": 3000},
- {"name": "log.4", "mtime": 4000},
- ]
- to_delete = files_to_delete(files, max_files=2)
- assert len(to_delete) == 2
- assert to_delete[0]["name"] == "log.1"
- assert to_delete[1]["name"] == "log.2"
-
- def test_compress_rotated_log(self):
- """Test determining if log should be compressed."""
-
- def should_compress(file_size, compression_threshold=1024 * 100):
- return file_size >= compression_threshold
-
- assert should_compress(1024 * 50) is False
- assert should_compress(1024 * 100) is True
- assert should_compress(1024 * 200) is True
-
-
-class TestLogAggregation:
- """Tests for log aggregation patterns."""
-
- def test_aggregate_by_level(self):
- """Test aggregating logs by level."""
-
- def aggregate_by_level(logs):
- result = {}
- for log in logs:
- level = log.get("level", "UNKNOWN")
- if level not in result:
- result[level] = {"count": 0, "messages": []}
- result[level]["count"] += 1
- result[level]["messages"].append(log.get("message"))
- return result
-
- logs = [
- {"level": "INFO", "message": "msg1"},
- {"level": "ERROR", "message": "err1"},
- {"level": "INFO", "message": "msg2"},
- ]
- agg = aggregate_by_level(logs)
- assert agg["INFO"]["count"] == 2
- assert agg["ERROR"]["count"] == 1
-
- def test_aggregate_by_time_bucket(self):
- """Test aggregating logs by time bucket."""
-
- def aggregate_by_time(logs, bucket_seconds=60):
- result = {}
- for log in logs:
- ts = log.get("timestamp", 0)
- bucket = (ts // bucket_seconds) * bucket_seconds
- if bucket not in result:
- result[bucket] = 0
- result[bucket] += 1
- return result
-
- logs = [
- {"timestamp": 1000}, # bucket 960 (960 <= 1000 < 1020)
- {"timestamp": 1030}, # bucket 1020 (1020 <= 1030 < 1080)
- {"timestamp": 1070}, # bucket 1020 (1020 <= 1070 < 1080)
- {"timestamp": 1130}, # bucket 1080 (1080 <= 1130 < 1140)
- ]
- agg = aggregate_by_time(logs, bucket_seconds=60)
- assert agg[960] == 1 # First bucket has 1 log (1000)
- assert agg[1020] == 2 # Second bucket has 2 logs (1030, 1070)
- assert agg[1080] == 1 # Third bucket has 1 log (1130)
-
- def test_top_error_messages(self):
- """Test finding top error messages."""
-
- def top_errors(logs, top_n=5):
- error_counts = {}
- for log in logs:
- if log.get("level") == "ERROR":
- msg = log.get("message", "")
- error_counts[msg] = error_counts.get(msg, 0) + 1
- sorted_errors = sorted(
- error_counts.items(), key=lambda x: x[1], reverse=True
- )
- return sorted_errors[:top_n]
-
- logs = [
- {"level": "ERROR", "message": "Connection failed"},
- {"level": "ERROR", "message": "Timeout"},
- {"level": "ERROR", "message": "Connection failed"},
- {"level": "INFO", "message": "OK"},
- ]
- top = top_errors(logs, top_n=2)
- assert top[0] == ("Connection failed", 2)
- assert top[1] == ("Timeout", 1)
-
- def test_calculate_percentiles(self):
- """Test calculating log latency percentiles."""
-
- def calculate_percentiles(values, percentiles):
- if not values:
- return {}
- sorted_values = sorted(values)
- n = len(sorted_values)
- result = {}
- for p in percentiles:
- index = int(p / 100 * (n - 1))
- result[f"p{p}"] = sorted_values[index]
- return result
-
- latencies = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
- percentiles = calculate_percentiles(latencies, [50, 90, 99])
- assert percentiles["p50"] == 50
- assert percentiles["p90"] == 90
diff --git a/tests/news/test_monitoring_patterns_behavior.py b/tests/news/test_monitoring_patterns_behavior.py
deleted file mode 100644
index 17a3b9345f..0000000000
--- a/tests/news/test_monitoring_patterns_behavior.py
+++ /dev/null
@@ -1,904 +0,0 @@
-"""
-Behavioral tests for monitoring patterns.
-
-These tests verify the logic of monitoring patterns like metrics collection,
-health checks, alerting, and observability without making actual system calls.
-"""
-
-import time
-from dataclasses import dataclass, field
-from enum import Enum
-
-
-class TestMetricsCollection:
- """Tests for metrics collection patterns."""
-
- def test_counter_increment(self):
- """Test counter metric incrementing."""
-
- class Counter:
- def __init__(self, name):
- self.name = name
- self.value = 0
-
- def inc(self, amount=1):
- self.value += amount
-
- def get(self):
- return self.value
-
- counter = Counter("requests_total")
- counter.inc()
- counter.inc(5)
- assert counter.get() == 6
-
- def test_gauge_set_value(self):
- """Test gauge metric setting."""
-
- class Gauge:
- def __init__(self, name):
- self.name = name
- self.value = 0
-
- def set(self, value):
- self.value = value
-
- def inc(self, amount=1):
- self.value += amount
-
- def dec(self, amount=1):
- self.value -= amount
-
- def get(self):
- return self.value
-
- gauge = Gauge("active_connections")
- gauge.set(10)
- assert gauge.get() == 10
- gauge.inc(5)
- assert gauge.get() == 15
- gauge.dec(3)
- assert gauge.get() == 12
-
- def test_histogram_record(self):
- """Test histogram metric recording."""
-
- class Histogram:
- def __init__(self, name, buckets):
- self.name = name
- self.buckets = sorted(buckets)
- self.bucket_counts = {b: 0 for b in self.buckets}
- self.bucket_counts[float("inf")] = 0
- self.sum = 0
- self.count = 0
-
- def observe(self, value):
- self.sum += value
- self.count += 1
- for bucket in self.buckets:
- if value <= bucket:
- self.bucket_counts[bucket] += 1
- self.bucket_counts[float("inf")] += 1
-
- def get_percentile(self, p):
- # Simplified percentile calculation
- if self.count == 0:
- return 0
- return self.sum / self.count # Return mean for simplicity
-
- histogram = Histogram("request_duration", [0.1, 0.5, 1.0, 5.0])
- histogram.observe(0.05)
- histogram.observe(0.3)
- histogram.observe(0.8)
- assert histogram.count == 3
- assert histogram.bucket_counts[0.1] == 1
- assert histogram.bucket_counts[0.5] == 2
- assert histogram.bucket_counts[1.0] == 3
-
- def test_summary_quantiles(self):
- """Test summary metric quantiles."""
-
- class Summary:
- def __init__(self, name):
- self.name = name
- self.values = []
-
- def observe(self, value):
- self.values.append(value)
-
- def quantile(self, q):
- if not self.values:
- return 0
- sorted_values = sorted(self.values)
- index = int(q * (len(sorted_values) - 1))
- return sorted_values[index]
-
- summary = Summary("response_size")
- for i in range(100):
- summary.observe(i)
- assert summary.quantile(0.5) == 49 # Median
- assert summary.quantile(0.9) == 89 # 90th percentile
-
- def test_metric_labels(self):
- """Test metrics with labels."""
-
- class LabeledCounter:
- def __init__(self, name, label_names):
- self.name = name
- self.label_names = label_names
- self.values = {}
-
- def labels(self, **kwargs):
- key = tuple(sorted(kwargs.items()))
- if key not in self.values:
- self.values[key] = 0
- return key
-
- def inc(self, label_key, amount=1):
- self.values[label_key] += amount
-
- def get(self, label_key):
- return self.values.get(label_key, 0)
-
- counter = LabeledCounter("requests", ["method", "endpoint"])
- key1 = counter.labels(method="GET", endpoint="/api/users")
- key2 = counter.labels(method="POST", endpoint="/api/users")
-
- counter.inc(key1, 5)
- counter.inc(key2, 3)
-
- assert counter.get(key1) == 5
- assert counter.get(key2) == 3
-
-
-class TestHealthChecks:
- """Tests for health check patterns."""
-
- def test_basic_health_check(self):
- """Test basic health check."""
-
- def health_check(services):
- status = {"healthy": True, "services": {}}
- for service, check_fn in services.items():
- try:
- is_healthy = check_fn()
- status["services"][service] = {
- "status": "healthy" if is_healthy else "unhealthy"
- }
- if not is_healthy:
- status["healthy"] = False
- except Exception as e:
- status["services"][service] = {
- "status": "unhealthy",
- "error": str(e),
- }
- status["healthy"] = False
- return status
-
- services = {
- "database": lambda: True,
- "cache": lambda: True,
- }
- result = health_check(services)
- assert result["healthy"] is True
-
- services["cache"] = lambda: False
- result = health_check(services)
- assert result["healthy"] is False
-
- def test_dependency_health_check(self):
- """Test dependency health check with timeout."""
-
- def check_dependency(check_fn, timeout_seconds=5):
- start = time.time()
- try:
- result = check_fn()
- duration = time.time() - start
- return {
- "healthy": result,
- "latency_ms": int(duration * 1000),
- }
- except Exception as e:
- return {"healthy": False, "error": str(e)}
-
- result = check_dependency(lambda: True)
- assert result["healthy"] is True
- assert "latency_ms" in result
-
- def test_readiness_vs_liveness(self):
- """Test readiness vs liveness probes."""
-
- class HealthProbes:
- def __init__(self):
- self.ready = False
- self.alive = True
-
- def liveness(self):
- return {"status": "alive" if self.alive else "dead"}
-
- def readiness(self):
- return {"status": "ready" if self.ready else "not_ready"}
-
- probes = HealthProbes()
- assert probes.liveness()["status"] == "alive"
- assert probes.readiness()["status"] == "not_ready"
-
- probes.ready = True
- assert probes.readiness()["status"] == "ready"
-
- def test_graceful_degradation(self):
- """Test graceful degradation health status."""
-
- def aggregate_health(checks):
- all_healthy = all(c["healthy"] for c in checks.values())
- any_healthy = any(c["healthy"] for c in checks.values())
-
- if all_healthy:
- return "healthy"
- if any_healthy:
- return "degraded"
- return "unhealthy"
-
- checks = {"db": {"healthy": True}, "cache": {"healthy": True}}
- assert aggregate_health(checks) == "healthy"
-
- checks["cache"]["healthy"] = False
- assert aggregate_health(checks) == "degraded"
-
- checks["db"]["healthy"] = False
- assert aggregate_health(checks) == "unhealthy"
-
- def test_health_check_caching(self):
- """Test caching health check results."""
-
- class CachedHealthCheck:
- def __init__(self, check_fn, cache_seconds=30):
- self.check_fn = check_fn
- self.cache_seconds = cache_seconds
- self.cached_result = None
- self.cached_at = 0
-
- def check(self):
- now = time.time()
- if (
- self.cached_result
- and (now - self.cached_at) < self.cache_seconds
- ):
- return self.cached_result
- self.cached_result = self.check_fn()
- self.cached_at = now
- return self.cached_result
-
- call_count = {"count": 0}
-
- def expensive_check():
- call_count["count"] += 1
- return True
-
- cached = CachedHealthCheck(expensive_check, cache_seconds=60)
- cached.check()
- cached.check()
- cached.check()
- assert call_count["count"] == 1 # Only called once due to cache
-
-
-class TestAlerting:
- """Tests for alerting patterns."""
-
- def test_threshold_alert(self):
- """Test threshold-based alerting."""
-
- def check_threshold(value, warning_threshold, critical_threshold):
- if value >= critical_threshold:
- return "critical"
- if value >= warning_threshold:
- return "warning"
- return "ok"
-
- assert check_threshold(50, 70, 90) == "ok"
- assert check_threshold(75, 70, 90) == "warning"
- assert check_threshold(95, 70, 90) == "critical"
-
- def test_alert_deduplication(self):
- """Test alert deduplication."""
-
- class AlertDeduplicator:
- def __init__(self, window_seconds=300):
- self.active_alerts = {}
- self.window_seconds = window_seconds
-
- def should_send(self, alert_key):
- now = time.time()
- if alert_key in self.active_alerts:
- last_sent = self.active_alerts[alert_key]
- if now - last_sent < self.window_seconds:
- return False
- self.active_alerts[alert_key] = now
- return True
-
- dedup = AlertDeduplicator(window_seconds=300)
- assert dedup.should_send("cpu_high") is True
- assert dedup.should_send("cpu_high") is False # Too soon
- assert dedup.should_send("memory_high") is True # Different alert
-
- def test_alert_grouping(self):
- """Test grouping related alerts."""
-
- def group_alerts(alerts, group_by="service"):
- groups = {}
- for alert in alerts:
- key = alert.get(group_by, "unknown")
- if key not in groups:
- groups[key] = []
- groups[key].append(alert)
- return groups
-
- alerts = [
- {"service": "api", "message": "High CPU"},
- {"service": "api", "message": "High memory"},
- {"service": "db", "message": "Slow queries"},
- ]
- groups = group_alerts(alerts, "service")
- assert len(groups["api"]) == 2
- assert len(groups["db"]) == 1
-
- def test_alert_severity(self):
- """Test alert severity classification."""
-
- class AlertSeverity(Enum):
- INFO = 1
- WARNING = 2
- ERROR = 3
- CRITICAL = 4
-
- def classify_alert(alert):
- if alert.get("error_rate", 0) > 50:
- return AlertSeverity.CRITICAL
- if alert.get("error_rate", 0) > 20:
- return AlertSeverity.ERROR
- if alert.get("error_rate", 0) > 5:
- return AlertSeverity.WARNING
- return AlertSeverity.INFO
-
- assert classify_alert({"error_rate": 60}) == AlertSeverity.CRITICAL
- assert classify_alert({"error_rate": 30}) == AlertSeverity.ERROR
- assert classify_alert({"error_rate": 10}) == AlertSeverity.WARNING
- assert classify_alert({"error_rate": 1}) == AlertSeverity.INFO
-
- def test_alert_routing(self):
- """Test routing alerts to different channels."""
-
- def route_alert(alert, routing_rules):
- channels = []
- for rule in routing_rules:
- if rule["match"](alert):
- channels.extend(rule["channels"])
- return list(set(channels)) # Deduplicate
-
- rules = [
- {
- "match": lambda a: a.get("severity") == "critical",
- "channels": ["pager", "slack"],
- },
- {
- "match": lambda a: a.get("severity") == "warning",
- "channels": ["slack"],
- },
- {
- "match": lambda a: a.get("service") == "payments",
- "channels": ["pager"],
- },
- ]
-
- alert1 = {"severity": "critical", "service": "api"}
- assert "pager" in route_alert(alert1, rules)
- assert "slack" in route_alert(alert1, rules)
-
- alert2 = {"severity": "warning", "service": "payments"}
- channels = route_alert(alert2, rules)
- assert "slack" in channels
- assert "pager" in channels
-
-
-class TestTracing:
- """Tests for distributed tracing patterns."""
-
- def test_generate_trace_id(self):
- """Test trace ID generation."""
- import secrets
-
- def generate_trace_id():
- return secrets.token_hex(16)
-
- trace_id = generate_trace_id()
- assert len(trace_id) == 32
- assert all(c in "0123456789abcdef" for c in trace_id)
-
- def test_span_context(self):
- """Test span context management."""
-
- @dataclass
- class SpanContext:
- trace_id: str
- span_id: str
- parent_span_id: str = None
-
- def create_child_span(parent_context):
- import secrets
-
- return SpanContext(
- trace_id=parent_context.trace_id,
- span_id=secrets.token_hex(8),
- parent_span_id=parent_context.span_id,
- )
-
- parent = SpanContext(trace_id="abc123", span_id="def456")
- child = create_child_span(parent)
- assert child.trace_id == parent.trace_id
- assert child.parent_span_id == parent.span_id
- assert child.span_id != parent.span_id
-
- def test_span_timing(self):
- """Test span timing."""
-
- @dataclass
- class Span:
- name: str
- start_time: float = field(default_factory=time.time)
- end_time: float = None
-
- def finish(self):
- self.end_time = time.time()
-
- @property
- def duration_ms(self):
- if self.end_time is None:
- return None
- return (self.end_time - self.start_time) * 1000
-
- span = Span(name="db_query")
- span.finish()
- assert span.duration_ms is not None
- assert span.duration_ms >= 0
-
- def test_span_tags(self):
- """Test span tagging."""
-
- @dataclass
- class Span:
- name: str
- tags: dict = field(default_factory=dict)
-
- def set_tag(self, key, value):
- self.tags[key] = value
- return self
-
- span = Span(name="http_request")
- span.set_tag("http.method", "GET").set_tag("http.status", 200)
- assert span.tags["http.method"] == "GET"
- assert span.tags["http.status"] == 200
-
- def test_trace_context_propagation(self):
- """Test trace context propagation headers."""
-
- def inject_context(context, headers):
- headers["traceparent"] = (
- f"00-{context['trace_id']}-{context['span_id']}-01"
- )
- return headers
-
- def extract_context(headers):
- traceparent = headers.get("traceparent", "")
- if traceparent:
- parts = traceparent.split("-")
- if len(parts) == 4:
- return {"trace_id": parts[1], "span_id": parts[2]}
- return None
-
- context = {"trace_id": "abc123def456", "span_id": "789abc"}
- headers = inject_context(context, {})
- extracted = extract_context(headers)
- assert extracted["trace_id"] == "abc123def456"
-
-
-class TestRateCalculation:
- """Tests for rate and throughput calculation."""
-
- def test_calculate_rate(self):
- """Test calculating rate per second."""
-
- def calculate_rate(count, duration_seconds):
- if duration_seconds == 0:
- return 0
- return count / duration_seconds
-
- assert calculate_rate(100, 10) == 10 # 10 per second
- assert calculate_rate(0, 10) == 0
- assert calculate_rate(100, 0) == 0
-
- def test_moving_average(self):
- """Test moving average calculation."""
-
- class MovingAverage:
- def __init__(self, window_size):
- self.window_size = window_size
- self.values = []
-
- def add(self, value):
- self.values.append(value)
- if len(self.values) > self.window_size:
- self.values.pop(0)
-
- def average(self):
- if not self.values:
- return 0
- return sum(self.values) / len(self.values)
-
- ma = MovingAverage(3)
- ma.add(10)
- ma.add(20)
- ma.add(30)
- assert ma.average() == 20
-
- ma.add(40)
- assert ma.average() == 30 # (20 + 30 + 40) / 3
-
- def test_exponential_moving_average(self):
- """Test exponential moving average."""
-
- class ExponentialMovingAverage:
- def __init__(self, alpha=0.1):
- self.alpha = alpha
- self.value = None
-
- def add(self, value):
- if self.value is None:
- self.value = value
- else:
- self.value = (
- self.alpha * value + (1 - self.alpha) * self.value
- )
-
- def get(self):
- return self.value
-
- ema = ExponentialMovingAverage(alpha=0.5)
- ema.add(100)
- assert ema.get() == 100
-
- ema.add(200)
- assert ema.get() == 150 # 0.5 * 200 + 0.5 * 100
-
- def test_percentile_calculation(self):
- """Test percentile calculation."""
-
- def calculate_percentile(values, percentile):
- if not values:
- return 0
- sorted_values = sorted(values)
- index = int((percentile / 100) * (len(sorted_values) - 1))
- return sorted_values[index]
-
- values = list(range(1, 101)) # 1 to 100
- assert calculate_percentile(values, 50) == 50
- assert calculate_percentile(values, 90) == 90
- assert calculate_percentile(values, 99) == 99
-
- def test_error_rate_calculation(self):
- """Test error rate calculation."""
-
- def calculate_error_rate(error_count, total_count):
- if total_count == 0:
- return 0
- return (error_count / total_count) * 100
-
- assert calculate_error_rate(5, 100) == 5.0
- assert calculate_error_rate(0, 100) == 0.0
- assert calculate_error_rate(10, 0) == 0
-
-
-class TestResourceMonitoring:
- """Tests for resource monitoring patterns."""
-
- def test_memory_usage_calculation(self):
- """Test memory usage calculation."""
-
- def calculate_memory_percent(used_bytes, total_bytes):
- if total_bytes == 0:
- return 0
- return (used_bytes / total_bytes) * 100
-
- assert calculate_memory_percent(4 * 1024**3, 16 * 1024**3) == 25.0
- assert calculate_memory_percent(8 * 1024**3, 16 * 1024**3) == 50.0
-
- def test_cpu_usage_average(self):
- """Test CPU usage averaging."""
-
- def average_cpu_usage(cpu_percents):
- if not cpu_percents:
- return 0
- return sum(cpu_percents) / len(cpu_percents)
-
- # 4 cores at different utilizations
- cpu_percents = [80, 60, 40, 20]
- assert average_cpu_usage(cpu_percents) == 50
-
- def test_disk_space_check(self):
- """Test disk space check."""
-
- def check_disk_space(
- used_bytes, total_bytes, warning_threshold=80, critical_threshold=90
- ):
- if total_bytes == 0:
- return "unknown"
- percent_used = (used_bytes / total_bytes) * 100
- if percent_used >= critical_threshold:
- return "critical"
- if percent_used >= warning_threshold:
- return "warning"
- return "ok"
-
- total = 100 * 1024**3 # 100 GB
- assert check_disk_space(50 * 1024**3, total) == "ok"
- assert check_disk_space(85 * 1024**3, total) == "warning"
- assert check_disk_space(95 * 1024**3, total) == "critical"
-
- def test_connection_pool_utilization(self):
- """Test connection pool utilization."""
-
- def pool_utilization(active_connections, max_connections):
- if max_connections == 0:
- return 0
- return (active_connections / max_connections) * 100
-
- assert pool_utilization(5, 20) == 25.0
- assert pool_utilization(18, 20) == 90.0
-
- def test_queue_depth_monitoring(self):
- """Test queue depth monitoring."""
-
- def analyze_queue(current_depth, max_depth, processing_rate):
- utilization = (
- (current_depth / max_depth) * 100 if max_depth > 0 else 0
- )
- estimated_drain_time = (
- current_depth / processing_rate
- if processing_rate > 0
- else float("inf")
- )
- return {
- "depth": current_depth,
- "utilization_percent": utilization,
- "estimated_drain_seconds": estimated_drain_time,
- }
-
- result = analyze_queue(100, 1000, 10)
- assert result["utilization_percent"] == 10.0
- assert result["estimated_drain_seconds"] == 10.0
-
-
-class TestSLOCalculation:
- """Tests for SLO/SLA calculation patterns."""
-
- def test_availability_calculation(self):
- """Test availability calculation."""
-
- def calculate_availability(uptime_seconds, total_seconds):
- if total_seconds == 0:
- return 100.0
- return (uptime_seconds / total_seconds) * 100
-
- # 30 days in seconds
- total = 30 * 24 * 3600
- # 99.9% uptime means ~43 minutes downtime
- downtime = 43 * 60
- uptime = total - downtime
- availability = calculate_availability(uptime, total)
- assert 99.9 <= availability <= 100
-
- def test_error_budget_calculation(self):
- """Test error budget calculation."""
-
- def calculate_error_budget(
- slo_target, current_availability, time_period_seconds
- ):
- error_budget_percent = 100 - slo_target
- max_downtime_seconds = (
- error_budget_percent / 100
- ) * time_period_seconds
- current_error_percent = 100 - current_availability
- used_budget_percent = (
- current_error_percent / error_budget_percent
- ) * 100
- remaining_budget_seconds = max_downtime_seconds * (
- 1 - used_budget_percent / 100
- )
- return {
- "max_downtime_seconds": max_downtime_seconds,
- "remaining_seconds": max(0, remaining_budget_seconds),
- "used_percent": used_budget_percent,
- }
-
- # 30 days, 99.9% SLO
- budget = calculate_error_budget(99.9, 99.95, 30 * 24 * 3600)
- assert budget["used_percent"] == 50.0 # Used half the budget
-
- def test_latency_slo(self):
- """Test latency SLO calculation."""
-
- def check_latency_slo(latencies, target_percentile, target_latency_ms):
- if not latencies:
- return {"compliant": True, "actual_percentile_ms": 0}
- sorted_latencies = sorted(latencies)
- index = int((target_percentile / 100) * (len(sorted_latencies) - 1))
- actual = sorted_latencies[index]
- return {
- "compliant": actual <= target_latency_ms,
- "actual_percentile_ms": actual,
- }
-
- latencies = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
- # P90 should be <= 100ms
- result = check_latency_slo(latencies, 90, 100)
- assert result["compliant"] is True
-
- # P90 should be <= 50ms (will fail)
- result = check_latency_slo(latencies, 90, 50)
- assert result["compliant"] is False
-
- def test_throughput_slo(self):
- """Test throughput SLO calculation."""
-
- def check_throughput_slo(requests_per_second, min_throughput):
- return {
- "compliant": requests_per_second >= min_throughput,
- "current_rps": requests_per_second,
- "min_required_rps": min_throughput,
- }
-
- result = check_throughput_slo(150, 100)
- assert result["compliant"] is True
-
- result = check_throughput_slo(80, 100)
- assert result["compliant"] is False
-
- def test_composite_slo(self):
- """Test composite SLO from multiple metrics."""
-
- def check_composite_slo(metrics, slo_definitions):
- results = {}
- all_compliant = True
- for name, definition in slo_definitions.items():
- value = metrics.get(name, 0)
- target = definition["target"]
- operator = definition.get("operator", ">=")
- if operator == ">=":
- compliant = value >= target
- elif operator == "<=":
- compliant = value <= target
- else:
- compliant = value == target
- results[name] = {
- "compliant": compliant,
- "value": value,
- "target": target,
- }
- if not compliant:
- all_compliant = False
- return {"overall_compliant": all_compliant, "details": results}
-
- metrics = {
- "availability": 99.95,
- "p99_latency_ms": 150,
- "error_rate": 0.5,
- }
- slos = {
- "availability": {"target": 99.9, "operator": ">="},
- "p99_latency_ms": {"target": 200, "operator": "<="},
- "error_rate": {"target": 1.0, "operator": "<="},
- }
- result = check_composite_slo(metrics, slos)
- assert result["overall_compliant"] is True
-
-
-class TestAnomalyDetection:
- """Tests for anomaly detection patterns."""
-
- def test_z_score_anomaly(self):
- """Test Z-score based anomaly detection."""
-
- def calculate_z_score(value, mean, std_dev):
- if std_dev == 0:
- return 0
- return (value - mean) / std_dev
-
- def is_anomaly(value, mean, std_dev, threshold=3):
- z_score = calculate_z_score(value, mean, std_dev)
- return abs(z_score) > threshold
-
- # Normal values
- assert is_anomaly(100, 100, 10) is False # Z=0
- assert is_anomaly(120, 100, 10) is False # Z=2
- # Anomaly
- assert is_anomaly(150, 100, 10) is True # Z=5
-
- def test_threshold_anomaly(self):
- """Test threshold-based anomaly detection."""
-
- def detect_threshold_anomaly(value, upper_bound=None, lower_bound=None):
- if upper_bound is not None and value > upper_bound:
- return {"is_anomaly": True, "type": "above_upper_bound"}
- if lower_bound is not None and value < lower_bound:
- return {"is_anomaly": True, "type": "below_lower_bound"}
- return {"is_anomaly": False}
-
- assert (
- detect_threshold_anomaly(150, upper_bound=100)["is_anomaly"] is True
- )
- assert (
- detect_threshold_anomaly(50, lower_bound=100)["is_anomaly"] is True
- )
- assert (
- detect_threshold_anomaly(75, upper_bound=100, lower_bound=50)[
- "is_anomaly"
- ]
- is False
- )
-
- def test_rate_of_change_anomaly(self):
- """Test rate of change anomaly detection."""
-
- def detect_rate_anomaly(current, previous, max_change_percent=50):
- if previous == 0:
- return current > 0
- change_percent = abs((current - previous) / previous) * 100
- return change_percent > max_change_percent
-
- assert (
- detect_rate_anomaly(150, 100) is False
- ) # 50% change - at threshold
- assert detect_rate_anomaly(200, 100) is True # 100% change - anomaly
- assert detect_rate_anomaly(100, 100) is False # No change
-
- def test_trend_detection(self):
- """Test trend detection."""
-
- def detect_trend(values, min_consecutive=3):
- if len(values) < min_consecutive:
- return "insufficient_data"
- increasing = 0
- decreasing = 0
- for i in range(1, len(values)):
- if values[i] > values[i - 1]:
- increasing += 1
- elif values[i] < values[i - 1]:
- decreasing += 1
- if increasing >= min_consecutive:
- return "increasing"
- if decreasing >= min_consecutive:
- return "decreasing"
- return "stable"
-
- assert detect_trend([1, 2, 3, 4, 5]) == "increasing"
- assert detect_trend([5, 4, 3, 2, 1]) == "decreasing"
- assert detect_trend([1, 2, 1, 2, 1]) == "stable"
-
- def test_seasonal_anomaly(self):
- """Test seasonal pattern anomaly detection."""
-
- def detect_seasonal_anomaly(
- value, expected_range, tolerance_percent=20
- ):
- expected_min, expected_max = expected_range
- tolerance = (expected_max - expected_min) * (
- tolerance_percent / 100
- )
- adjusted_min = expected_min - tolerance
- adjusted_max = expected_max + tolerance
- return value < adjusted_min or value > adjusted_max
-
- # Expected traffic between 1000-2000 for this hour
- expected = (1000, 2000)
- assert detect_seasonal_anomaly(1500, expected) is False # Normal
- assert detect_seasonal_anomaly(500, expected) is True # Too low
- assert detect_seasonal_anomaly(3000, expected) is True # Too high
diff --git a/tests/news/test_news_analyzer_logic_behavior.py b/tests/news/test_news_analyzer_logic_behavior.py
deleted file mode 100644
index 4d1e3f77fc..0000000000
--- a/tests/news/test_news_analyzer_logic_behavior.py
+++ /dev/null
@@ -1,698 +0,0 @@
-"""
-Deep behavioral tests for news_analyzer.py pure logic methods.
-Tests _validate_news_item, _count_categories, _summarize_impact,
-_empty_analysis, _prepare_snippets, extract_topics dedup, and
-watch_for bullet parsing patterns.
-"""
-
-from datetime import datetime, timezone
-
-
-# --- _validate_news_item ---
-
-
-class TestValidateNewsItem:
- """Tests for news item validation logic."""
-
- def _validate(self, item):
- required = ["headline", "summary"]
- return all(field in item and item[field] for field in required)
-
- def test_valid_item(self):
- item = {"headline": "Breaking News", "summary": "Something happened"}
- assert self._validate(item) is True
-
- def test_missing_headline(self):
- item = {"summary": "Something happened"}
- assert self._validate(item) is False
-
- def test_missing_summary(self):
- item = {"headline": "Breaking News"}
- assert self._validate(item) is False
-
- def test_empty_headline(self):
- item = {"headline": "", "summary": "Something"}
- assert self._validate(item) is False
-
- def test_empty_summary(self):
- item = {"headline": "News", "summary": ""}
- assert self._validate(item) is False
-
- def test_both_empty(self):
- item = {"headline": "", "summary": ""}
- assert self._validate(item) is False
-
- def test_both_missing(self):
- assert self._validate({}) is False
-
- def test_extra_fields_ok(self):
- item = {
- "headline": "News",
- "summary": "Details",
- "category": "Tech",
- "impact_score": 8,
- }
- assert self._validate(item) is True
-
- def test_none_headline(self):
- item = {"headline": None, "summary": "Details"}
- assert self._validate(item) is False
-
- def test_none_summary(self):
- item = {"headline": "News", "summary": None}
- assert self._validate(item) is False
-
- def test_whitespace_headline_is_valid(self):
- item = {"headline": " ", "summary": "Details"}
- assert self._validate(item) is True # non-empty string
-
- def test_zero_headline_is_falsy(self):
- item = {"headline": 0, "summary": "Details"}
- assert self._validate(item) is False
-
-
-# --- _count_categories ---
-
-
-class TestCountCategories:
- """Tests for category counting logic."""
-
- def _count(self, items):
- counts = {}
- for item in items:
- cat = item.get("category", "Other")
- counts[cat] = counts.get(cat, 0) + 1
- return counts
-
- def test_empty_items(self):
- assert self._count([]) == {}
-
- def test_single_category(self):
- items = [{"category": "Tech"}]
- assert self._count(items) == {"Tech": 1}
-
- def test_multiple_same_category(self):
- items = [
- {"category": "Tech"},
- {"category": "Tech"},
- {"category": "Tech"},
- ]
- assert self._count(items) == {"Tech": 3}
-
- def test_multiple_categories(self):
- items = [
- {"category": "Tech"},
- {"category": "Science"},
- {"category": "Tech"},
- ]
- result = self._count(items)
- assert result == {"Tech": 2, "Science": 1}
-
- def test_missing_category_defaults_to_other(self):
- items = [{"headline": "No category"}]
- assert self._count(items) == {"Other": 1}
-
- def test_mixed_with_and_without_category(self):
- items = [{"category": "Tech"}, {"headline": "No cat"}]
- result = self._count(items)
- assert result == {"Tech": 1, "Other": 1}
-
- def test_many_categories(self):
- items = [{"category": f"Cat{i}"} for i in range(10)]
- result = self._count(items)
- assert len(result) == 10
- assert all(v == 1 for v in result.values())
-
- def test_empty_string_category(self):
- items = [{"category": ""}]
- result = self._count(items)
- # Empty string is falsy but .get returns it, not "Other"
- assert result == {"": 1}
-
-
-# --- _summarize_impact ---
-
-
-class TestSummarizeImpact:
- """Tests for impact score summarization."""
-
- def _summarize(self, items):
- if not items:
- return {"average": 0, "high_impact_count": 0}
- scores = [item.get("impact_score", 5) for item in items]
- return {
- "average": sum(scores) / len(scores),
- "high_impact_count": len([s for s in scores if s >= 8]),
- "max": max(scores),
- "min": min(scores),
- }
-
- def test_empty_items(self):
- result = self._summarize([])
- assert result["average"] == 0
- assert result["high_impact_count"] == 0
-
- def test_single_item(self):
- result = self._summarize([{"impact_score": 7}])
- assert result["average"] == 7
- assert result["high_impact_count"] == 0
- assert result["max"] == 7
- assert result["min"] == 7
-
- def test_high_impact(self):
- items = [{"impact_score": 9}, {"impact_score": 8}]
- result = self._summarize(items)
- assert result["high_impact_count"] == 2
-
- def test_mixed_impact(self):
- items = [{"impact_score": 9}, {"impact_score": 3}]
- result = self._summarize(items)
- assert result["average"] == 6.0
- assert result["high_impact_count"] == 1
- assert result["max"] == 9
- assert result["min"] == 3
-
- def test_default_score_when_missing(self):
- items = [{"headline": "No score"}]
- result = self._summarize(items)
- assert result["average"] == 5 # default
-
- def test_all_high_impact(self):
- items = [{"impact_score": 10}, {"impact_score": 8}, {"impact_score": 9}]
- result = self._summarize(items)
- assert result["high_impact_count"] == 3
-
- def test_no_high_impact(self):
- items = [{"impact_score": 3}, {"impact_score": 5}, {"impact_score": 7}]
- result = self._summarize(items)
- assert result["high_impact_count"] == 0
-
- def test_boundary_impact_8(self):
- items = [{"impact_score": 8}]
- result = self._summarize(items)
- assert result["high_impact_count"] == 1
-
- def test_boundary_impact_7(self):
- items = [{"impact_score": 7}]
- result = self._summarize(items)
- assert result["high_impact_count"] == 0
-
- def test_average_precision(self):
- items = [{"impact_score": 1}, {"impact_score": 2}, {"impact_score": 3}]
- result = self._summarize(items)
- assert result["average"] == 2.0
-
-
-# --- _empty_analysis ---
-
-
-class TestEmptyAnalysis:
- """Tests for empty analysis structure."""
-
- def _empty(self):
- return {
- "items": [],
- "item_count": 0,
- "big_picture": "",
- "watch_for": [],
- "patterns": "",
- "topics": [],
- "categories": {},
- "impact_summary": {"average": 0, "high_impact_count": 0},
- "timestamp": datetime.now(timezone.utc).isoformat(),
- }
-
- def test_items_empty_list(self):
- result = self._empty()
- assert result["items"] == []
-
- def test_item_count_zero(self):
- result = self._empty()
- assert result["item_count"] == 0
-
- def test_big_picture_empty(self):
- result = self._empty()
- assert result["big_picture"] == ""
-
- def test_watch_for_empty(self):
- result = self._empty()
- assert result["watch_for"] == []
-
- def test_patterns_empty(self):
- result = self._empty()
- assert result["patterns"] == ""
-
- def test_topics_empty(self):
- result = self._empty()
- assert result["topics"] == []
-
- def test_categories_empty(self):
- result = self._empty()
- assert result["categories"] == {}
-
- def test_impact_summary_zeroed(self):
- result = self._empty()
- assert result["impact_summary"]["average"] == 0
- assert result["impact_summary"]["high_impact_count"] == 0
-
- def test_has_timestamp(self):
- result = self._empty()
- assert "timestamp" in result
- assert len(result["timestamp"]) > 10
-
- def test_all_keys_present(self):
- result = self._empty()
- expected_keys = {
- "items",
- "item_count",
- "big_picture",
- "watch_for",
- "patterns",
- "topics",
- "categories",
- "impact_summary",
- "timestamp",
- }
- assert set(result.keys()) == expected_keys
-
-
-# --- _prepare_snippets ---
-
-
-class TestPrepareSnippets:
- """Tests for search result snippet preparation."""
-
- def _prepare(self, results):
- snippets = []
- for i, result in enumerate(results):
- snippet = f"[{i + 1}] "
- if result.get("title"):
- snippet += f"Title: {result['title']}\n"
- if result.get("url"):
- snippet += f"URL: {result['url']}\n"
- if result.get("snippet"):
- snippet += f"Snippet: {result['snippet'][:200]}...\n"
- elif result.get("content"):
- snippet += f"Content: {result['content'][:200]}...\n"
- snippets.append(snippet)
- return "\n".join(snippets)
-
- def test_empty_results(self):
- assert self._prepare([]) == ""
-
- def test_with_title(self):
- results = [{"title": "Big News"}]
- output = self._prepare(results)
- assert "Title: Big News" in output
-
- def test_with_url(self):
- results = [{"url": "https://example.com"}]
- output = self._prepare(results)
- assert "URL: https://example.com" in output
-
- def test_with_snippet(self):
- results = [{"snippet": "Some content here"}]
- output = self._prepare(results)
- assert "Snippet: Some content here" in output
-
- def test_content_fallback_when_no_snippet(self):
- results = [{"content": "Full article text"}]
- output = self._prepare(results)
- assert "Content: Full article text" in output
-
- def test_snippet_preferred_over_content(self):
- results = [{"snippet": "Short", "content": "Long content"}]
- output = self._prepare(results)
- assert "Snippet: Short" in output
- assert "Content:" not in output
-
- def test_numbering(self):
- results = [{"title": "A"}, {"title": "B"}, {"title": "C"}]
- output = self._prepare(results)
- assert "[1]" in output
- assert "[2]" in output
- assert "[3]" in output
-
- def test_snippet_truncation_at_200(self):
- results = [{"snippet": "X" * 500}]
- output = self._prepare(results)
- # Should contain truncated snippet plus "..."
- assert "X" * 200 in output
- assert "X" * 201 not in output
-
- def test_content_truncation_at_200(self):
- results = [{"content": "Y" * 500}]
- output = self._prepare(results)
- assert "Y" * 200 in output
- assert "Y" * 201 not in output
-
- def test_all_fields(self):
- results = [
- {
- "title": "Title",
- "url": "https://x.com",
- "snippet": "Snippet text",
- }
- ]
- output = self._prepare(results)
- assert "Title: Title" in output
- assert "URL: https://x.com" in output
- assert "Snippet: Snippet text" in output
-
- def test_missing_all_fields(self):
- results = [{}]
- output = self._prepare(results)
- assert output.strip() == "[1]"
-
-
-# --- Watch for bullet parsing ---
-
-
-class TestWatchForBulletParsing:
- """Tests for parsing LLM watch-for bullet points."""
-
- def _parse_bullets(self, content):
- lines = content.strip().split("\n")
- watch_items = []
- for line in lines:
- line = line.strip()
- if line and line not in ["WATCH FOR:", "Watch for:"]:
- line = line.lstrip("-•* ")
- if line:
- watch_items.append(line)
- return watch_items[:5]
-
- def test_standard_bullets(self):
- content = "- Item 1\n- Item 2\n- Item 3"
- result = self._parse_bullets(content)
- assert result == ["Item 1", "Item 2", "Item 3"]
-
- def test_removes_header(self):
- content = "WATCH FOR:\n- Item 1\n- Item 2"
- result = self._parse_bullets(content)
- assert "WATCH FOR:" not in result
- assert len(result) == 2
-
- def test_removes_lowercase_header(self):
- content = "Watch for:\n- Item 1"
- result = self._parse_bullets(content)
- assert "Watch for:" not in result
-
- def test_asterisk_bullets(self):
- content = "* Item 1\n* Item 2"
- result = self._parse_bullets(content)
- assert result == ["Item 1", "Item 2"]
-
- def test_dot_bullets(self):
- content = "• Point 1\n• Point 2"
- result = self._parse_bullets(content)
- assert result == ["Point 1", "Point 2"]
-
- def test_max_5_items(self):
- content = "\n".join(f"- Item {i}" for i in range(10))
- result = self._parse_bullets(content)
- assert len(result) == 5
-
- def test_skips_empty_lines(self):
- content = "- Item 1\n\n- Item 2\n\n"
- result = self._parse_bullets(content)
- assert result == ["Item 1", "Item 2"]
-
- def test_strips_whitespace(self):
- content = " - Item 1 \n - Item 2 "
- result = self._parse_bullets(content)
- assert result == ["Item 1", "Item 2"]
-
- def test_no_bullet_markers(self):
- content = "Plain text line 1\nPlain text line 2"
- result = self._parse_bullets(content)
- assert result == ["Plain text line 1", "Plain text line 2"]
-
- def test_empty_content(self):
- result = self._parse_bullets("")
- assert result == []
-
-
-# --- Developing story filter ---
-
-
-class TestDevelopingStoryFilter:
- """Tests for developing story filtering logic in generate_watch_for."""
-
- def _filter_developing(self, items):
- developing = [
- item for item in items if item.get("is_developing", False)
- ]
- if not developing:
- developing = items[:5]
- return developing
-
- def test_filters_developing_true(self):
- items = [
- {"headline": "A", "is_developing": True},
- {"headline": "B", "is_developing": False},
- {"headline": "C", "is_developing": True},
- ]
- result = self._filter_developing(items)
- assert len(result) == 2
- assert all(r["is_developing"] for r in result)
-
- def test_fallback_to_first_5_when_none_developing(self):
- items = [
- {"headline": f"News {i}", "is_developing": False} for i in range(10)
- ]
- result = self._filter_developing(items)
- assert len(result) == 5
-
- def test_empty_items(self):
- result = self._filter_developing([])
- assert result == []
-
- def test_all_developing(self):
- items = [{"headline": f"N{i}", "is_developing": True} for i in range(3)]
- result = self._filter_developing(items)
- assert len(result) == 3
-
- def test_missing_is_developing_key(self):
- items = [{"headline": "A"}, {"headline": "B"}]
- result = self._filter_developing(items)
- # No is_developing key -> defaults to False -> fallback to first 5
- assert len(result) == 2 # less than 5, returns all
-
-
-# --- Category grouping for patterns ---
-
-
-class TestCategoryGrouping:
- """Tests for category grouping used in generate_patterns."""
-
- def _group_by_category(self, items):
- by_category = {}
- for item in items:
- cat = item.get("category", "Other")
- if cat not in by_category:
- by_category[cat] = []
- by_category[cat].append(item["headline"])
- return by_category
-
- def test_empty(self):
- assert self._group_by_category([]) == {}
-
- def test_single_category(self):
- items = [
- {"headline": "A", "category": "Tech"},
- {"headline": "B", "category": "Tech"},
- ]
- result = self._group_by_category(items)
- assert result == {"Tech": ["A", "B"]}
-
- def test_multiple_categories(self):
- items = [
- {"headline": "A", "category": "Tech"},
- {"headline": "B", "category": "Science"},
- ]
- result = self._group_by_category(items)
- assert "Tech" in result
- assert "Science" in result
-
- def test_default_category(self):
- items = [{"headline": "A"}]
- result = self._group_by_category(items)
- assert result == {"Other": ["A"]}
-
- def test_category_summary_format(self):
- items = [
- {"headline": "A", "category": "Tech"},
- {"headline": "B", "category": "Tech"},
- {"headline": "C", "category": "Science"},
- ]
- by_category = self._group_by_category(items)
- summary = "\n".join(
- f"{cat}: {len(headlines)} stories"
- for cat, headlines in by_category.items()
- )
- assert "Tech: 2 stories" in summary
- assert "Science: 1 stories" in summary
-
-
-# --- Topic deduplication logic ---
-
-
-class TestTopicDeduplication:
- """Tests for extract_topics deduplication logic."""
-
- def _dedup_topics(self, topics_list):
- topic_counts = {}
- topic_metadata = {}
- for info in topics_list:
- name = info["name"]
- if name not in topic_counts:
- topic_counts[name] = 0
- topic_metadata[name] = info
- topic_counts[name] += 1
- if info["impact_score"] > topic_metadata[name]["impact_score"]:
- topic_metadata[name] = info
-
- final = []
- for topic, count in sorted(
- topic_counts.items(), key=lambda x: x[1], reverse=True
- ):
- metadata = topic_metadata[topic]
- metadata["frequency"] = count
- metadata["query"] = f"{topic} latest developments news"
- final.append(metadata)
- return final[:10]
-
- def test_single_topic(self):
- topics = [{"name": "AI", "impact_score": 7}]
- result = self._dedup_topics(topics)
- assert len(result) == 1
- assert result[0]["frequency"] == 1
-
- def test_deduplicates_same_name(self):
- topics = [
- {"name": "AI", "impact_score": 5},
- {"name": "AI", "impact_score": 8},
- ]
- result = self._dedup_topics(topics)
- assert len(result) == 1
- assert result[0]["frequency"] == 2
-
- def test_keeps_highest_impact(self):
- topics = [
- {"name": "AI", "impact_score": 3},
- {"name": "AI", "impact_score": 9},
- ]
- result = self._dedup_topics(topics)
- assert result[0]["impact_score"] == 9
-
- def test_sorts_by_frequency(self):
- topics = [
- {"name": "AI", "impact_score": 5},
- {"name": "AI", "impact_score": 5},
- {"name": "Climate", "impact_score": 5},
- ]
- result = self._dedup_topics(topics)
- assert result[0]["name"] == "AI"
-
- def test_max_10_topics(self):
- topics = [{"name": f"Topic{i}", "impact_score": 5} for i in range(15)]
- result = self._dedup_topics(topics)
- assert len(result) == 10
-
- def test_generates_query_field(self):
- topics = [{"name": "climate", "impact_score": 7}]
- result = self._dedup_topics(topics)
- assert result[0]["query"] == "climate latest developments news"
-
- def test_empty_topics(self):
- result = self._dedup_topics([])
- assert result == []
-
- def test_multiple_unique_topics(self):
- topics = [
- {"name": "AI", "impact_score": 5},
- {"name": "Climate", "impact_score": 7},
- {"name": "Economy", "impact_score": 3},
- ]
- result = self._dedup_topics(topics)
- assert len(result) == 3
-
-
-# --- analyze_news components structure ---
-
-
-class TestAnalyzeNewsComponentsStructure:
- """Tests for analyze_news return structure when items exist."""
-
- def _build_components(self, news_items, search_results):
- components = {
- "items": news_items,
- "item_count": len(news_items),
- "search_result_count": len(search_results),
- "timestamp": datetime.now(timezone.utc).isoformat(),
- }
- return components
-
- def test_item_count_matches(self):
- items = [{"headline": "A"}, {"headline": "B"}]
- components = self._build_components(items, items)
- assert components["item_count"] == 2
-
- def test_search_result_count(self):
- components = self._build_components([], [1, 2, 3])
- assert components["search_result_count"] == 3
-
- def test_has_timestamp(self):
- components = self._build_components([], [])
- assert "timestamp" in components
-
- def test_items_preserved(self):
- items = [{"headline": "Test"}]
- components = self._build_components(items, items)
- assert components["items"] == items
-
- def test_empty_items_zero_count(self):
- components = self._build_components([], [])
- assert components["item_count"] == 0
-
-
-# --- Summary truncation for LLM prompts ---
-
-
-class TestSummaryTruncation:
- """Tests for summary truncation used in big_picture/watch_for prompts."""
-
- def _prepare_summaries(self, items, max_items=10):
- return "\n".join(
- f"- {item['headline']}: {item.get('summary', '')[:100]}..."
- for item in items[:max_items]
- )
-
- def test_basic_summary(self):
- items = [
- {"headline": "AI News", "summary": "Something happened with AI"}
- ]
- result = self._prepare_summaries(items)
- assert "AI News: Something happened with AI..." in result
-
- def test_truncates_at_100_chars(self):
- items = [{"headline": "News", "summary": "A" * 200}]
- result = self._prepare_summaries(items)
- assert "A" * 100 in result
- assert "A" * 101 not in result
-
- def test_max_10_items(self):
- items = [{"headline": f"H{i}", "summary": f"S{i}"} for i in range(20)]
- result = self._prepare_summaries(items)
- assert "H9" in result
- assert "H10" not in result
-
- def test_missing_summary(self):
- items = [{"headline": "News"}]
- result = self._prepare_summaries(items)
- assert "News: ..." in result
-
- def test_empty_items(self):
- result = self._prepare_summaries([])
- assert result == ""
diff --git a/tests/news/test_news_filtering_patterns_behavior.py b/tests/news/test_news_filtering_patterns_behavior.py
deleted file mode 100644
index 059ace7aa1..0000000000
--- a/tests/news/test_news_filtering_patterns_behavior.py
+++ /dev/null
@@ -1,562 +0,0 @@
-"""
-Deep behavioral tests for news filtering patterns.
-Tests category filtering, topic filtering, time filtering,
-impact filtering, and combined filter logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-
-
-# --- Category filtering patterns ---
-
-
-class TestCategoryFiltering:
- """Tests for category-based filtering."""
-
- def _filter_by_category(self, items, category):
- """Filter items by category."""
- if not category or category == "all":
- return items
- return [i for i in items if i.get("category") == category]
-
- def test_filters_matching(self):
- items = [
- {"id": "1", "category": "Tech"},
- {"id": "2", "category": "Science"},
- {"id": "3", "category": "Tech"},
- ]
- result = self._filter_by_category(items, "Tech")
- assert len(result) == 2
- assert all(i["category"] == "Tech" for i in result)
-
- def test_no_match_returns_empty(self):
- items = [{"id": "1", "category": "Tech"}]
- result = self._filter_by_category(items, "Sports")
- assert result == []
-
- def test_all_category_returns_all(self):
- items = [{"id": "1"}, {"id": "2"}]
- result = self._filter_by_category(items, "all")
- assert len(result) == 2
-
- def test_none_category_returns_all(self):
- items = [{"id": "1"}, {"id": "2"}]
- result = self._filter_by_category(items, None)
- assert len(result) == 2
-
-
-class TestMultipleCategoryFiltering:
- """Tests for filtering by multiple categories."""
-
- def _filter_by_categories(self, items, categories):
- """Filter items by multiple categories."""
- if not categories:
- return items
- return [i for i in items if i.get("category") in categories]
-
- def test_multiple_categories(self):
- items = [
- {"id": "1", "category": "Tech"},
- {"id": "2", "category": "Science"},
- {"id": "3", "category": "Sports"},
- ]
- result = self._filter_by_categories(items, ["Tech", "Science"])
- assert len(result) == 2
-
- def test_single_category_in_list(self):
- items = [
- {"id": "1", "category": "Tech"},
- {"id": "2", "category": "Science"},
- ]
- result = self._filter_by_categories(items, ["Tech"])
- assert len(result) == 1
-
-
-# --- Topic filtering patterns ---
-
-
-class TestTopicFiltering:
- """Tests for topic-based filtering."""
-
- def _filter_by_topic(self, items, topic):
- """Filter items containing a topic."""
- if not topic:
- return items
- topic_lower = topic.lower()
- return [
- i
- for i in items
- if any(topic_lower in t.lower() for t in i.get("topics", []))
- ]
-
- def test_filters_matching_topic(self):
- items = [
- {"id": "1", "topics": ["AI", "ML"]},
- {"id": "2", "topics": ["Climate"]},
- ]
- result = self._filter_by_topic(items, "AI")
- assert len(result) == 1
- assert result[0]["id"] == "1"
-
- def test_case_insensitive(self):
- items = [{"id": "1", "topics": ["Artificial Intelligence"]}]
- result = self._filter_by_topic(items, "artificial")
- assert len(result) == 1
-
- def test_partial_match(self):
- items = [{"id": "1", "topics": ["Climate Change"]}]
- result = self._filter_by_topic(items, "climate")
- assert len(result) == 1
-
- def test_no_topic_returns_all(self):
- items = [{"id": "1"}, {"id": "2"}]
- result = self._filter_by_topic(items, None)
- assert len(result) == 2
-
-
-class TestMultipleTopicFiltering:
- """Tests for filtering by multiple topics."""
-
- def _filter_by_topics(self, items, topics, match_all=False):
- """Filter items by multiple topics."""
- if not topics:
- return items
- topics_lower = [t.lower() for t in topics]
- result = []
- for item in items:
- item_topics = [t.lower() for t in item.get("topics", [])]
- if match_all:
- matches = all(
- any(t in it for it in item_topics) for t in topics_lower
- )
- else:
- matches = any(
- any(t in it for it in item_topics) for t in topics_lower
- )
- if matches:
- result.append(item)
- return result
-
- def test_match_any(self):
- items = [
- {"id": "1", "topics": ["AI"]},
- {"id": "2", "topics": ["Climate"]},
- ]
- result = self._filter_by_topics(items, ["AI", "Climate"])
- assert len(result) == 2
-
- def test_match_all(self):
- items = [
- {"id": "1", "topics": ["AI", "ML"]},
- {"id": "2", "topics": ["AI"]},
- ]
- result = self._filter_by_topics(items, ["AI", "ML"], match_all=True)
- assert len(result) == 1
-
-
-# --- Time filtering patterns ---
-
-
-class TestTimeFiltering:
- """Tests for time-based filtering."""
-
- def _filter_by_time(self, items, hours):
- """Filter items from the last N hours."""
- if not hours:
- return items
- cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
- return [i for i in items if i.get("created_at", cutoff) >= cutoff]
-
- def test_filters_recent(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(hours=48)
- items = [
- {"id": "1", "created_at": now},
- {"id": "2", "created_at": old},
- ]
- result = self._filter_by_time(items, 24)
- assert len(result) == 1
- assert result[0]["id"] == "1"
-
- def test_all_within_range(self):
- now = datetime.now(timezone.utc)
- items = [{"id": str(i), "created_at": now} for i in range(5)]
- result = self._filter_by_time(items, 24)
- assert len(result) == 5
-
- def test_none_hours_returns_all(self):
- items = [{"id": "1"}, {"id": "2"}]
- result = self._filter_by_time(items, None)
- assert len(result) == 2
-
-
-class TestDateRangeFiltering:
- """Tests for date range filtering."""
-
- def _filter_by_date_range(self, items, start_date, end_date):
- """Filter items within a date range."""
- result = []
- for item in items:
- created = item.get("created_at")
- if not created:
- continue
- if start_date and created < start_date:
- continue
- if end_date and created > end_date:
- continue
- result.append(item)
- return result
-
- def test_within_range(self):
- start = datetime(2025, 6, 1, tzinfo=timezone.utc)
- end = datetime(2025, 6, 30, tzinfo=timezone.utc)
- items = [
- {
- "id": "1",
- "created_at": datetime(2025, 6, 15, tzinfo=timezone.utc),
- },
- {
- "id": "2",
- "created_at": datetime(2025, 5, 15, tzinfo=timezone.utc),
- },
- ]
- result = self._filter_by_date_range(items, start, end)
- assert len(result) == 1
-
- def test_no_start(self):
- end = datetime(2025, 6, 30, tzinfo=timezone.utc)
- items = [
- {
- "id": "1",
- "created_at": datetime(2025, 6, 15, tzinfo=timezone.utc),
- }
- ]
- result = self._filter_by_date_range(items, None, end)
- assert len(result) == 1
-
- def test_no_end(self):
- start = datetime(2025, 6, 1, tzinfo=timezone.utc)
- items = [
- {
- "id": "1",
- "created_at": datetime(2025, 6, 15, tzinfo=timezone.utc),
- }
- ]
- result = self._filter_by_date_range(items, start, None)
- assert len(result) == 1
-
-
-# --- Impact filtering patterns ---
-
-
-class TestImpactFiltering:
- """Tests for impact score filtering."""
-
- def _filter_by_impact(self, items, min_impact=0, max_impact=10):
- """Filter items by impact score range."""
- return [
- i
- for i in items
- if min_impact <= i.get("impact_score", 5) <= max_impact
- ]
-
- def test_min_impact(self):
- items = [
- {"id": "1", "impact_score": 3},
- {"id": "2", "impact_score": 7},
- {"id": "3", "impact_score": 9},
- ]
- result = self._filter_by_impact(items, min_impact=5)
- assert len(result) == 2
-
- def test_max_impact(self):
- items = [
- {"id": "1", "impact_score": 3},
- {"id": "2", "impact_score": 7},
- ]
- result = self._filter_by_impact(items, max_impact=5)
- assert len(result) == 1
-
- def test_range(self):
- items = [
- {"id": "1", "impact_score": 3},
- {"id": "2", "impact_score": 5},
- {"id": "3", "impact_score": 9},
- ]
- result = self._filter_by_impact(items, min_impact=4, max_impact=6)
- assert len(result) == 1
-
- def test_default_impact_5(self):
- items = [{"id": "1"}] # No impact_score
- result = self._filter_by_impact(items, min_impact=5, max_impact=5)
- assert len(result) == 1 # Default is 5
-
-
-class TestHighImpactFiltering:
- """Tests for high impact filtering."""
-
- def _filter_high_impact(self, items, threshold=7):
- """Filter high impact items."""
- return [i for i in items if i.get("impact_score", 0) >= threshold]
-
- def test_filters_high_impact(self):
- items = [
- {"id": "1", "impact_score": 5},
- {"id": "2", "impact_score": 8},
- {"id": "3", "impact_score": 9},
- ]
- result = self._filter_high_impact(items)
- assert len(result) == 2
-
- def test_custom_threshold(self):
- items = [{"id": "1", "impact_score": 5}]
- result = self._filter_high_impact(items, threshold=4)
- assert len(result) == 1
-
-
-# --- Status filtering patterns ---
-
-
-class TestStatusFiltering:
- """Tests for status-based filtering."""
-
- def _filter_by_status(self, items, status):
- """Filter items by status."""
- if not status:
- return items
- return [i for i in items if i.get("status") == status]
-
- def test_active_only(self):
- items = [
- {"id": "1", "status": "active"},
- {"id": "2", "status": "archived"},
- ]
- result = self._filter_by_status(items, "active")
- assert len(result) == 1
-
- def test_archived_only(self):
- items = [
- {"id": "1", "status": "active"},
- {"id": "2", "status": "archived"},
- ]
- result = self._filter_by_status(items, "archived")
- assert len(result) == 1
-
-
-class TestExcludeStatuses:
- """Tests for excluding certain statuses."""
-
- def _exclude_statuses(self, items, exclude_list):
- """Exclude items with certain statuses."""
- if not exclude_list:
- return items
- return [i for i in items if i.get("status") not in exclude_list]
-
- def test_excludes_archived(self):
- items = [
- {"id": "1", "status": "active"},
- {"id": "2", "status": "archived"},
- ]
- result = self._exclude_statuses(items, ["archived"])
- assert len(result) == 1
- assert result[0]["status"] == "active"
-
- def test_excludes_multiple(self):
- items = [
- {"id": "1", "status": "active"},
- {"id": "2", "status": "archived"},
- {"id": "3", "status": "deleted"},
- ]
- result = self._exclude_statuses(items, ["archived", "deleted"])
- assert len(result) == 1
-
-
-# --- Source filtering patterns ---
-
-
-class TestSourceFiltering:
- """Tests for source-based filtering."""
-
- def _filter_by_source(self, items, source_type):
- """Filter items by source type."""
- if not source_type:
- return items
- return [
- i for i in items if i.get("source", {}).get("type") == source_type
- ]
-
- def test_filters_by_source(self):
- items = [
- {"id": "1", "source": {"type": "subscription"}},
- {"id": "2", "source": {"type": "trending"}},
- ]
- result = self._filter_by_source(items, "subscription")
- assert len(result) == 1
-
- def test_no_source_type_returns_all(self):
- items = [{"id": "1"}, {"id": "2"}]
- result = self._filter_by_source(items, None)
- assert len(result) == 2
-
-
-# --- Combined filter patterns ---
-
-
-class TestCombinedFilters:
- """Tests for combining multiple filters."""
-
- def _apply_filters(self, items, filters):
- """Apply multiple filters."""
- result = items
- if filters.get("category"):
- result = [
- i for i in result if i.get("category") == filters["category"]
- ]
- if filters.get("min_impact"):
- result = [
- i
- for i in result
- if i.get("impact_score", 0) >= filters["min_impact"]
- ]
- if filters.get("status"):
- result = [i for i in result if i.get("status") == filters["status"]]
- return result
-
- def test_category_and_impact(self):
- items = [
- {"id": "1", "category": "Tech", "impact_score": 8},
- {"id": "2", "category": "Tech", "impact_score": 3},
- {"id": "3", "category": "Science", "impact_score": 9},
- ]
- result = self._apply_filters(
- items, {"category": "Tech", "min_impact": 5}
- )
- assert len(result) == 1
- assert result[0]["id"] == "1"
-
- def test_no_filters(self):
- items = [{"id": "1"}, {"id": "2"}]
- result = self._apply_filters(items, {})
- assert len(result) == 2
-
-
-# --- Viewed filter patterns ---
-
-
-class TestViewedFiltering:
- """Tests for filtering by viewed status."""
-
- def _filter_viewed(self, items, include_viewed=True):
- """Filter items by viewed status."""
- if include_viewed:
- return items
- return [i for i in items if not i.get("interaction", {}).get("viewed")]
-
- def test_include_viewed(self):
- items = [
- {"id": "1", "interaction": {"viewed": True}},
- {"id": "2", "interaction": {"viewed": False}},
- ]
- result = self._filter_viewed(items, include_viewed=True)
- assert len(result) == 2
-
- def test_exclude_viewed(self):
- items = [
- {"id": "1", "interaction": {"viewed": True}},
- {"id": "2", "interaction": {"viewed": False}},
- ]
- result = self._filter_viewed(items, include_viewed=False)
- assert len(result) == 1
- assert result[0]["id"] == "2"
-
-
-# --- Subscription filter patterns ---
-
-
-class TestSubscriptionFiltering:
- """Tests for subscription-based filtering."""
-
- def _filter_by_subscription(self, items, subscription_id):
- """Filter items by subscription."""
- if not subscription_id or subscription_id == "all":
- return items
- return [i for i in items if i.get("subscription_id") == subscription_id]
-
- def test_filters_by_subscription(self):
- items = [
- {"id": "1", "subscription_id": "sub-1"},
- {"id": "2", "subscription_id": "sub-2"},
- ]
- result = self._filter_by_subscription(items, "sub-1")
- assert len(result) == 1
-
- def test_all_subscription(self):
- items = [{"id": "1"}, {"id": "2"}]
- result = self._filter_by_subscription(items, "all")
- assert len(result) == 2
-
-
-# --- User filter patterns ---
-
-
-class TestUserFiltering:
- """Tests for user-based filtering."""
-
- def _filter_by_user(self, items, user_id):
- """Filter items by user."""
- if not user_id:
- return items
- return [i for i in items if i.get("user_id") == user_id]
-
- def test_filters_by_user(self):
- items = [
- {"id": "1", "user_id": "u1"},
- {"id": "2", "user_id": "u2"},
- {"id": "3", "user_id": "u1"},
- ]
- result = self._filter_by_user(items, "u1")
- assert len(result) == 2
-
- def test_no_user_returns_all(self):
- items = [{"id": "1"}, {"id": "2"}]
- result = self._filter_by_user(items, None)
- assert len(result) == 2
-
-
-# --- Search query filter patterns ---
-
-
-class TestSearchQueryFiltering:
- """Tests for search query filtering."""
-
- def _filter_by_query(self, items, query):
- """Filter items by search query."""
- if not query:
- return items
- query_lower = query.lower()
- return [
- i
- for i in items
- if query_lower in i.get("headline", "").lower()
- or query_lower in i.get("summary", "").lower()
- ]
-
- def test_matches_headline(self):
- items = [
- {"id": "1", "headline": "AI News Today"},
- {"id": "2", "headline": "Weather Report"},
- ]
- result = self._filter_by_query(items, "AI")
- assert len(result) == 1
-
- def test_matches_summary(self):
- items = [
- {"id": "1", "summary": "Discussion about artificial intelligence"},
- ]
- result = self._filter_by_query(items, "artificial")
- assert len(result) == 1
-
- def test_case_insensitive(self):
- items = [{"id": "1", "headline": "AI NEWS"}]
- result = self._filter_by_query(items, "ai")
- assert len(result) == 1
diff --git a/tests/news/test_news_item_construction_behavior.py b/tests/news/test_news_item_construction_behavior.py
deleted file mode 100644
index 7c1701ed46..0000000000
--- a/tests/news/test_news_item_construction_behavior.py
+++ /dev/null
@@ -1,456 +0,0 @@
-"""
-Deep behavioral tests for news item construction patterns.
-Tests the news_item dict construction from api.py, ID formatting,
-default values, and field mapping.
-"""
-
-from datetime import datetime, timezone
-
-
-# --- News item ID format ---
-
-
-class TestNewsItemIdFormat:
- """Tests for the news-{research_id} ID format from api.py:387."""
-
- def test_prefix_format(self):
- research_id = "abc-123"
- news_id = f"news-{research_id}"
- assert news_id == "news-abc-123"
-
- def test_uuid_id(self):
- research_id = "550e8400-e29b-41d4-a716-446655440000"
- news_id = f"news-{research_id}"
- assert news_id.startswith("news-")
-
- def test_numeric_id(self):
- research_id = "42"
- news_id = f"news-{research_id}"
- assert news_id == "news-42"
-
-
-# --- Default values ---
-
-
-class TestNewsItemDefaults:
- """Tests for news item default values from api.py:386-418."""
-
- def test_default_impact_score(self):
- metadata = {}
- impact_score = metadata.get("impact_score", 0)
- assert impact_score == 0
-
- def test_metadata_impact_score(self):
- metadata = {"impact_score": 7}
- impact_score = metadata.get("impact_score", 0)
- assert impact_score == 7
-
- def test_default_upvotes(self):
- metadata = {}
- upvotes = metadata.get("upvotes", 0)
- assert upvotes == 0
-
- def test_default_downvotes(self):
- metadata = {}
- downvotes = metadata.get("downvotes", 0)
- assert downvotes == 0
-
- def test_default_priority(self):
- metadata = {}
- priority = metadata.get("priority", "normal")
- assert priority == "normal"
-
- def test_custom_priority(self):
- metadata = {"priority": "high"}
- priority = metadata.get("priority", "normal")
- assert priority == "high"
-
- def test_default_is_news(self):
- metadata = {}
- is_news = metadata.get("is_news_search", False)
- assert is_news is False
-
- def test_is_news_true(self):
- metadata = {"is_news_search": True}
- is_news = metadata.get("is_news_search", False)
- assert is_news is True
-
- def test_news_date_none(self):
- metadata = {}
- news_date = metadata.get("news_date")
- assert news_date is None
-
- def test_news_source_none(self):
- metadata = {}
- news_source = metadata.get("news_source")
- assert news_source is None
-
-
-# --- source_url format ---
-
-
-class TestSourceUrlFormat:
- """Tests for source_url construction from api.py:399."""
-
- def test_source_url_format(self):
- research_id = "abc-123"
- source_url = f"/results/{research_id}"
- assert source_url == "/results/abc-123"
-
- def test_source_url_with_uuid(self):
- research_id = "550e8400-e29b-41d4-a716-446655440000"
- source_url = f"/results/{research_id}"
- assert source_url.startswith("/results/")
-
-
-# --- Summary fallback ---
-
-
-class TestSummaryFallback:
- """Tests for summary fallback logic from api.py:391."""
-
- def test_summary_used_when_available(self):
- summary = "This is a summary"
- headline = "Test Headline"
- result = summary or f"Research analysis for: {headline[:100]}"
- assert result == "This is a summary"
-
- def test_headline_fallback(self):
- summary = ""
- headline = "Test Headline"
- result = summary or f"Research analysis for: {headline[:100]}"
- assert result == "Research analysis for: Test Headline"
-
- def test_headline_truncated_at_100(self):
- summary = ""
- headline = "A" * 200
- result = summary or f"Research analysis for: {headline[:100]}"
- assert len(result) == len("Research analysis for: ") + 100
-
- def test_none_summary_triggers_fallback(self):
- summary = None
- headline = "Test"
- result = summary or f"Research analysis for: {headline[:100]}"
- assert result.startswith("Research analysis for:")
-
-
-# --- News feed response structure ---
-
-
-class TestNewsFeedResponse:
- """Tests for the news feed response structure from api.py:467-474."""
-
- def test_response_has_news_items(self):
- response = {
- "news_items": [],
- "generated_at": datetime.now(timezone.utc).isoformat(),
- "focus": None,
- "search_strategy": "default",
- "total_items": 0,
- "source": "research_history",
- }
- assert "news_items" in response
-
- def test_response_has_generated_at(self):
- response = {
- "news_items": [],
- "generated_at": datetime.now(timezone.utc).isoformat(),
- "focus": None,
- "search_strategy": "default",
- "total_items": 0,
- "source": "research_history",
- }
- assert "generated_at" in response
- assert "T" in response["generated_at"]
-
- def test_response_has_focus(self):
- response = {
- "news_items": [],
- "generated_at": datetime.now(timezone.utc).isoformat(),
- "focus": "technology",
- "search_strategy": "default",
- "total_items": 0,
- "source": "research_history",
- }
- assert response["focus"] == "technology"
-
- def test_response_default_strategy(self):
- search_strategy = None
- response_strategy = search_strategy or "default"
- assert response_strategy == "default"
-
- def test_response_custom_strategy(self):
- search_strategy = "news_aggregation"
- response_strategy = search_strategy or "default"
- assert response_strategy == "news_aggregation"
-
- def test_news_items_limited(self):
- items = list(range(50))
- limit = 20
- result = items[:limit]
- assert len(result) == 20
-
-
-# --- Limit validation ---
-
-
-class TestLimitValidation:
- """Tests for the limit validation pattern from api.py:109-111."""
-
- def test_zero_limit_invalid(self):
- limit = 0
- assert limit < 1
-
- def test_negative_limit_invalid(self):
- limit = -5
- assert limit < 1
-
- def test_one_limit_valid(self):
- limit = 1
- assert limit >= 1
-
- def test_large_limit_valid(self):
- limit = 1000
- assert limit >= 1
-
-
-# --- Subscription dict format ---
-
-
-class TestSubscriptionDictFormat:
- """Tests for subscription dict construction patterns from api.py:731-754."""
-
- def test_search_iterations_default(self):
- search_iterations = None
- result = search_iterations or 3
- assert result == 3
-
- def test_search_iterations_custom(self):
- search_iterations = 5
- result = search_iterations or 3
- assert result == 5
-
- def test_questions_per_iteration_default(self):
- questions = None
- result = questions or 5
- assert result == 5
-
- def test_questions_per_iteration_custom(self):
- questions = 10
- result = questions or 5
- assert result == 10
-
- def test_is_active_from_status(self):
- status = "active"
- is_active = status == "active"
- assert is_active is True
-
- def test_is_active_from_paused(self):
- status = "paused"
- is_active = status == "active"
- assert is_active is False
-
- def test_is_active_from_expired(self):
- status = "expired"
- is_active = status == "active"
- assert is_active is False
-
-
-# --- History item processing ---
-
-
-class TestHistoryItemProcessing:
- """Tests for history item processing from api.py:630-659."""
-
- def _process_item(self, item):
- """Reproduce history item processing from api.py."""
- processed = {
- "research_id": item.get("uuid_id") or str(item.get("id")),
- "query": item["query"],
- "status": item["status"],
- "created_at": item["created_at"],
- "completed_at": item.get("completed_at"),
- "duration_seconds": item.get("duration_seconds", 0),
- "url": f"/progress/{item.get('uuid_id') or item.get('id')}",
- }
- return processed
-
- def test_uses_uuid_id(self):
- item = {
- "uuid_id": "uuid-1",
- "id": 42,
- "query": "test",
- "status": "completed",
- "created_at": "2025-01-01",
- }
- result = self._process_item(item)
- assert result["research_id"] == "uuid-1"
-
- def test_falls_back_to_id(self):
- item = {
- "uuid_id": None,
- "id": 42,
- "query": "test",
- "status": "completed",
- "created_at": "2025-01-01",
- }
- result = self._process_item(item)
- assert result["research_id"] == "42"
-
- def test_url_format(self):
- item = {
- "uuid_id": "uuid-1",
- "id": 42,
- "query": "test",
- "status": "completed",
- "created_at": "2025-01-01",
- }
- result = self._process_item(item)
- assert result["url"] == "/progress/uuid-1"
-
- def test_default_duration(self):
- item = {
- "uuid_id": "uuid-1",
- "id": 42,
- "query": "test",
- "status": "completed",
- "created_at": "2025-01-01",
- }
- result = self._process_item(item)
- assert result["duration_seconds"] == 0
-
- def test_custom_duration(self):
- item = {
- "uuid_id": "uuid-1",
- "id": 42,
- "query": "test",
- "status": "completed",
- "created_at": "2025-01-01",
- "duration_seconds": 120,
- }
- result = self._process_item(item)
- assert result["duration_seconds"] == 120
-
- def test_completed_at_none(self):
- item = {
- "uuid_id": "uuid-1",
- "id": 42,
- "query": "test",
- "status": "in_progress",
- "created_at": "2025-01-01",
- }
- result = self._process_item(item)
- assert result["completed_at"] is None
-
-
-# --- Metadata headline/topics extraction from history ---
-
-
-class TestMetadataHeadlineTopicsExtraction:
- """Tests for headline/topics extraction from research_meta in history items."""
-
- def _extract_headline_topics(self, research_meta):
- """Reproduce extraction from api.py:641-657."""
- import json
-
- if research_meta:
- try:
- meta = json.loads(research_meta)
- return {
- "triggered_by": meta.get("triggered_by", "subscription"),
- "headline": meta.get("generated_headline", "[No headline]"),
- "topics": meta.get("generated_topics", []),
- }
- except Exception:
- return {
- "headline": "[No headline]",
- "topics": [],
- }
- return {
- "headline": "[No headline]",
- "topics": [],
- }
-
- def test_extracts_headline(self):
- import json
-
- meta = json.dumps({"generated_headline": "Breaking News"})
- result = self._extract_headline_topics(meta)
- assert result["headline"] == "Breaking News"
-
- def test_extracts_topics(self):
- import json
-
- meta = json.dumps({"generated_topics": ["AI", "Tech"]})
- result = self._extract_headline_topics(meta)
- assert result["topics"] == ["AI", "Tech"]
-
- def test_default_headline(self):
- import json
-
- meta = json.dumps({})
- result = self._extract_headline_topics(meta)
- assert result["headline"] == "[No headline]"
-
- def test_default_topics(self):
- import json
-
- meta = json.dumps({})
- result = self._extract_headline_topics(meta)
- assert result["topics"] == []
-
- def test_triggered_by_default(self):
- import json
-
- meta = json.dumps({})
- result = self._extract_headline_topics(meta)
- assert result["triggered_by"] == "subscription"
-
- def test_triggered_by_custom(self):
- import json
-
- meta = json.dumps({"triggered_by": "manual"})
- result = self._extract_headline_topics(meta)
- assert result["triggered_by"] == "manual"
-
- def test_none_meta(self):
- result = self._extract_headline_topics(None)
- assert result["headline"] == "[No headline]"
-
- def test_empty_meta(self):
- result = self._extract_headline_topics("")
- assert result["headline"] == "[No headline]"
-
- def test_invalid_json(self):
- result = self._extract_headline_topics("not json")
- assert result["headline"] == "[No headline]"
-
-
-# --- Like pattern construction ---
-
-
-class TestLikePatternConstruction:
- """Tests for LIKE pattern construction from api.py:789."""
-
- def test_subscription_id_pattern(self):
- sub_id = "sub-123-abc"
- pattern = f'%"subscription_id": "{sub_id}"%'
- assert '"subscription_id": "sub-123-abc"' in pattern
- assert pattern.startswith("%")
- assert pattern.endswith("%")
-
- def test_pattern_with_uuid(self):
- sub_id = "550e8400-e29b-41d4-a716-446655440000"
- pattern = f'%"subscription_id": "{sub_id}"%'
- assert sub_id in pattern
-
- def test_pattern_matches_json(self):
- import json
-
- sub_id = "sub-123"
- pattern_content = f'"subscription_id": "{sub_id}"'
- json_str = json.dumps(
- {"subscription_id": sub_id, "other": "data"}, indent=None
- )
- # json.dumps with no indent uses ": " separator
- assert pattern_content in json_str
diff --git a/tests/news/test_news_query_detection_behavior.py b/tests/news/test_news_query_detection_behavior.py
deleted file mode 100644
index 5657752776..0000000000
--- a/tests/news/test_news_query_detection_behavior.py
+++ /dev/null
@@ -1,643 +0,0 @@
-"""
-Deep behavioral tests for news query detection heuristics.
-Tests the is_news_query and has_news_metadata logic from api.py,
-metadata parsing patterns, and content processing logic.
-"""
-
-import json
-import re
-
-
-# --- has_news_metadata detection ---
-
-
-class TestHasNewsMetadata:
- """Tests for the has_news_metadata detection heuristic."""
-
- def _has_news_metadata(self, metadata):
- """Reproduce the has_news_metadata check from api.py:212-215."""
- return (
- metadata.get("generated_headline") is not None
- or metadata.get("generated_topics") is not None
- )
-
- def test_headline_present(self):
- assert self._has_news_metadata(
- {"generated_headline": "AI Breakthrough"}
- )
-
- def test_topics_present(self):
- assert self._has_news_metadata({"generated_topics": ["AI", "Climate"]})
-
- def test_both_present(self):
- assert self._has_news_metadata(
- {"generated_headline": "Test", "generated_topics": ["AI"]}
- )
-
- def test_neither_present(self):
- assert not self._has_news_metadata({})
-
- def test_empty_headline_is_truthy(self):
- """Empty string is not None, so it counts as present."""
- assert self._has_news_metadata({"generated_headline": ""})
-
- def test_empty_topics_list_is_truthy(self):
- """Empty list is not None, so it counts as present."""
- assert self._has_news_metadata({"generated_topics": []})
-
- def test_none_headline_is_falsy(self):
- assert not self._has_news_metadata({"generated_headline": None})
-
- def test_none_topics_is_falsy(self):
- assert not self._has_news_metadata({"generated_topics": None})
-
- def test_unrelated_keys_ignored(self):
- assert not self._has_news_metadata({"title": "Test", "other": "data"})
-
- def test_headline_none_topics_present(self):
- assert self._has_news_metadata(
- {"generated_headline": None, "generated_topics": ["AI"]}
- )
-
-
-# --- is_news_query detection ---
-
-
-class TestIsNewsQuery:
- """Tests for the is_news_query detection heuristic."""
-
- def _is_news_query(self, query, metadata, has_news_metadata=False):
- """Reproduce the is_news_query check from api.py:218-232."""
- query_lower = query.lower()
- return (
- has_news_metadata
- or metadata.get("is_news_search")
- or metadata.get("search_type") == "news_analysis"
- or "breaking news" in query_lower
- or "news stories" in query_lower
- or (
- "today" in query_lower
- and ("news" in query_lower or "breaking" in query_lower)
- )
- or "latest news" in query_lower
- )
-
- def test_has_news_metadata_makes_news(self):
- assert self._is_news_query("anything", {}, has_news_metadata=True)
-
- def test_is_news_search_flag(self):
- assert self._is_news_query("test", {"is_news_search": True})
-
- def test_search_type_news_analysis(self):
- assert self._is_news_query("test", {"search_type": "news_analysis"})
-
- def test_breaking_news_in_query(self):
- assert self._is_news_query("What is the breaking news about AI?", {})
-
- def test_news_stories_in_query(self):
- assert self._is_news_query("Latest news stories about climate", {})
-
- def test_today_and_news_in_query(self):
- assert self._is_news_query("What news happened today?", {})
-
- def test_today_and_breaking_in_query(self):
- assert self._is_news_query("What is breaking today?", {})
-
- def test_latest_news_in_query(self):
- assert self._is_news_query("latest news about tech", {})
-
- def test_regular_query_not_news(self):
- assert not self._is_news_query("How to cook pasta", {})
-
- def test_today_alone_not_news(self):
- assert not self._is_news_query("What happened today?", {})
-
- def test_news_alone_not_news(self):
- """Just 'news' in query without matching patterns is not detected."""
- assert not self._is_news_query("I read some news yesterday", {})
-
- def test_case_insensitive_breaking(self):
- assert self._is_news_query("BREAKING NEWS about AI", {})
-
- def test_case_insensitive_latest(self):
- assert self._is_news_query("LATEST NEWS update", {})
-
- def test_search_type_not_news_analysis(self):
- assert not self._is_news_query("test", {"search_type": "general"})
-
- def test_is_news_search_false(self):
- assert not self._is_news_query("test", {"is_news_search": False})
-
- def test_is_news_search_none(self):
- assert not self._is_news_query("test", {"is_news_search": None})
-
-
-# --- Metadata parsing ---
-
-
-class TestMetadataParsing:
- """Tests for the JSON metadata parsing pattern from api.py:198-208."""
-
- def _parse_metadata(self, research_meta):
- """Reproduce metadata parsing from api.py."""
- metadata = {}
- if research_meta:
- try:
- if isinstance(research_meta, dict):
- metadata = research_meta
- else:
- metadata = json.loads(research_meta)
- except (json.JSONDecodeError, TypeError):
- metadata = {}
- return metadata
-
- def test_dict_input(self):
- result = self._parse_metadata({"key": "val"})
- assert result == {"key": "val"}
-
- def test_json_string_input(self):
- result = self._parse_metadata('{"key": "val"}')
- assert result == {"key": "val"}
-
- def test_none_input(self):
- result = self._parse_metadata(None)
- assert result == {}
-
- def test_empty_string(self):
- result = self._parse_metadata("")
- assert result == {}
-
- def test_invalid_json(self):
- result = self._parse_metadata("not json")
- assert result == {}
-
- def test_empty_dict(self):
- result = self._parse_metadata({})
- assert result == {}
-
- def test_complex_json(self):
- data = {"generated_headline": "Test", "generated_topics": ["AI"]}
- result = self._parse_metadata(json.dumps(data))
- assert result["generated_headline"] == "Test"
-
- def test_nested_dict(self):
- result = self._parse_metadata({"nested": {"deep": True}})
- assert result["nested"]["deep"] is True
-
- def test_dict_not_re_parsed(self):
- """Dict input should be used directly, not serialized/deserialized."""
- original = {"key": "val"}
- result = self._parse_metadata(original)
- assert result is original
-
- def test_integer_input(self):
- result = self._parse_metadata(42)
- assert result == {}
-
- def test_list_input(self):
- result = self._parse_metadata([1, 2, 3])
- # json.loads on a list string works, but isinstance check fails
- # and json.loads(list) raises TypeError
- assert result == {}
-
-
-# --- Link extraction from content ---
-
-
-class TestLinkExtraction:
- """Tests for link extraction logic from api.py:332-379."""
-
- def _extract_links(self, content, max_links=3):
- """Reproduce link extraction from api.py."""
- links = []
- if not content:
- return links
- try:
- report_lines = content.split("\n")
- link_count = 0
- for i, line in enumerate(report_lines[:100]):
- if "URL:" in line:
- url = line.split("URL:", 1)[1].strip()
- if url.startswith("http"):
- title = ""
- if i > 0:
- title_line = report_lines[i - 1].strip()
- title = re.sub(
- r"^\[[^\]]+\]\s*", "", title_line
- ).strip()
- if not title:
- domain = url.split("//")[-1].split("/")[0]
- title = domain.replace("www.", "")
- links.append(
- {
- "url": url,
- "title": title[:50] + "..."
- if len(title) > 50
- else title,
- }
- )
- link_count += 1
- if link_count >= max_links:
- break
- except Exception:
- pass
- return links
-
- def test_empty_content(self):
- assert self._extract_links("") == []
-
- def test_none_content(self):
- assert self._extract_links(None) == []
-
- def test_no_links_in_content(self):
- content = "This is just regular text.\nNo links here."
- assert self._extract_links(content) == []
-
- def test_single_link(self):
- content = "Article Title\nURL: https://example.com/article"
- links = self._extract_links(content)
- assert len(links) == 1
- assert links[0]["url"] == "https://example.com/article"
-
- def test_title_from_previous_line(self):
- content = "Important Article\nURL: https://example.com/article"
- links = self._extract_links(content)
- assert links[0]["title"] == "Important Article"
-
- def test_max_three_links(self):
- lines = []
- for i in range(10):
- lines.append(f"Title {i}")
- lines.append(f"URL: https://example.com/{i}")
- content = "\n".join(lines)
- links = self._extract_links(content)
- assert len(links) == 3
-
- def test_non_http_url_ignored(self):
- content = "Title\nURL: ftp://example.com/file"
- links = self._extract_links(content)
- assert len(links) == 0
-
- def test_strips_citation_numbers(self):
- content = "[12, 26] Article Title\nURL: https://example.com/article"
- links = self._extract_links(content)
- assert links[0]["title"] == "Article Title"
-
- def test_domain_fallback_when_no_title(self):
- content = "URL: https://reuters.com/article/test"
- links = self._extract_links(content)
- assert links[0]["title"] == "reuters.com"
-
- def test_www_stripped_from_domain(self):
- content = "URL: https://www.bbc.com/news/article"
- links = self._extract_links(content)
- assert links[0]["title"] == "bbc.com"
-
- def test_title_truncated_at_50(self):
- long_title = "A" * 60
- content = f"{long_title}\nURL: https://example.com/article"
- links = self._extract_links(content)
- assert len(links[0]["title"]) == 53 # 50 + "..."
- assert links[0]["title"].endswith("...")
-
- def test_title_not_truncated_if_short(self):
- content = "Short Title\nURL: https://example.com/article"
- links = self._extract_links(content)
- assert links[0]["title"] == "Short Title"
- assert "..." not in links[0]["title"]
-
- def test_url_with_query_params(self):
- content = "Title\nURL: https://example.com/article?id=123&lang=en"
- links = self._extract_links(content)
- assert links[0]["url"] == "https://example.com/article?id=123&lang=en"
-
- def test_only_first_100_lines_checked(self):
- lines = ["Regular line"] * 100
- lines.append("Title")
- lines.append("URL: https://example.com/hidden")
- content = "\n".join(lines)
- links = self._extract_links(content)
- assert len(links) == 0
-
- def test_multiple_urls_on_same_line_takes_first(self):
- content = "Title\nURL: https://first.com URL: https://second.com"
- links = self._extract_links(content)
- # split("URL:", 1) means only first URL is captured
- assert "first.com" in links[0]["url"]
-
- def test_empty_url_after_prefix(self):
- content = "Title\nURL: "
- links = self._extract_links(content)
- assert len(links) == 0 # Empty string doesn't start with http
-
-
-# --- Content summary extraction ---
-
-
-class TestContentSummaryExtraction:
- """Tests for summary extraction from content lines (api.py:263-269)."""
-
- def _extract_summary(self, content):
- """Reproduce summary extraction from api.py."""
- if not content:
- return ""
- lines = content.split("\n")
- for line in lines:
- if line.strip() and not line.startswith("#"):
- return line.strip()
- return ""
-
- def test_first_non_empty_line(self):
- content = "\n\nThis is the summary.\nMore text."
- assert self._extract_summary(content) == "This is the summary."
-
- def test_skips_headers(self):
- content = "# Header\nThis is content."
- assert self._extract_summary(content) == "This is content."
-
- def test_skips_empty_lines(self):
- content = "\n\n\nFirst real line."
- assert self._extract_summary(content) == "First real line."
-
- def test_empty_content(self):
- assert self._extract_summary("") == ""
-
- def test_none_content(self):
- assert self._extract_summary(None) == ""
-
- def test_only_headers(self):
- content = "# Header 1\n# Header 2\n## Sub header"
- assert self._extract_summary(content) == ""
-
- def test_only_empty_lines(self):
- content = "\n\n\n"
- assert self._extract_summary(content) == ""
-
- def test_strips_whitespace(self):
- content = " Summary with spaces "
- assert self._extract_summary(content) == "Summary with spaces"
-
-
-# --- Headline generation fallback ---
-
-
-class TestHeadlineGenerationFallback:
- """Tests for headline generation fallback logic from api.py:280-294."""
-
- def _get_headline(self, row, metadata):
- """Reproduce headline generation from api.py."""
- headline = row.get("title") or metadata.get("generated_headline")
- if not headline and metadata.get("is_news_search"):
- subscription_name = metadata.get("subscription_name")
- if subscription_name:
- headline = f"News Update: {subscription_name}"
- else:
- headline = f"News: {row['query'][:60]}..."
- return headline
-
- def test_uses_title_first(self):
- result = self._get_headline(
- {"title": "DB Title", "query": "test"},
- {"generated_headline": "Meta Headline"},
- )
- assert result == "DB Title"
-
- def test_uses_metadata_headline_if_no_title(self):
- result = self._get_headline(
- {"title": None, "query": "test"},
- {"generated_headline": "Meta Headline"},
- )
- assert result == "Meta Headline"
-
- def test_subscription_name_fallback(self):
- result = self._get_headline(
- {"title": None, "query": "test"},
- {"is_news_search": True, "subscription_name": "My Feed"},
- )
- assert result == "News Update: My Feed"
-
- def test_query_fallback(self):
- result = self._get_headline(
- {"title": None, "query": "What's happening in AI today?"},
- {"is_news_search": True},
- )
- assert result.startswith("News: ")
- assert "AI" in result
-
- def test_query_truncated_at_60(self):
- long_query = "A" * 100
- result = self._get_headline(
- {"title": None, "query": long_query},
- {"is_news_search": True},
- )
- # "News: " + 60 chars + "..."
- assert len(result) == len("News: ") + 60 + len("...")
-
- def test_no_fallback_for_non_news(self):
- result = self._get_headline(
- {"title": None, "query": "test"},
- {"is_news_search": False},
- )
- assert result is None
-
- def test_empty_title_falls_through(self):
- """Empty string is falsy, should fall through."""
- result = self._get_headline(
- {"title": "", "query": "test"},
- {"generated_headline": "Headline"},
- )
- assert result == "Headline"
-
- def test_both_none_no_news_returns_none(self):
- result = self._get_headline(
- {"title": None, "query": "test"},
- {},
- )
- assert result is None
-
-
-# --- Category and topics defaults ---
-
-
-class TestCategoryTopicsDefaults:
- """Tests for category and topics default logic from api.py:324-330."""
-
- def test_category_from_metadata(self):
- metadata = {"category": "Technology"}
- category = metadata.get("category")
- if not category:
- category = "[Uncategorized]"
- assert category == "Technology"
-
- def test_category_default(self):
- metadata = {}
- category = metadata.get("category")
- if not category:
- category = "[Uncategorized]"
- assert category == "[Uncategorized]"
-
- def test_category_none_gets_default(self):
- metadata = {"category": None}
- category = metadata.get("category")
- if not category:
- category = "[Uncategorized]"
- assert category == "[Uncategorized]"
-
- def test_topics_from_metadata(self):
- metadata = {"generated_topics": ["AI", "Climate"]}
- topics = metadata.get("generated_topics")
- if not topics:
- topics = ["[No topics]"]
- assert topics == ["AI", "Climate"]
-
- def test_topics_default(self):
- metadata = {}
- topics = metadata.get("generated_topics")
- if not topics:
- topics = ["[No topics]"]
- assert topics == ["[No topics]"]
-
- def test_topics_empty_list_gets_default(self):
- metadata = {"generated_topics": []}
- topics = metadata.get("generated_topics")
- if not topics:
- topics = ["[No topics]"]
- assert topics == ["[No topics]"]
-
-
-# --- Source determination ---
-
-
-class TestSourceDetermination:
- """Tests for source determination logic from api.py:461-465."""
-
- def test_news_items_source(self):
- news_items = [{"is_news": True}, {"is_news": False}]
- source = (
- "news_items"
- if any(item.get("is_news", False) for item in news_items)
- else "research_history"
- )
- assert source == "news_items"
-
- def test_research_history_source(self):
- news_items = [{"is_news": False}, {"is_news": False}]
- source = (
- "news_items"
- if any(item.get("is_news", False) for item in news_items)
- else "research_history"
- )
- assert source == "research_history"
-
- def test_empty_items_source(self):
- news_items = []
- source = (
- "news_items"
- if any(item.get("is_news", False) for item in news_items)
- else "research_history"
- )
- assert source == "research_history"
-
- def test_all_news_items(self):
- news_items = [{"is_news": True}, {"is_news": True}]
- source = (
- "news_items"
- if any(item.get("is_news", False) for item in news_items)
- else "research_history"
- )
- assert source == "news_items"
-
- def test_missing_is_news_key(self):
- news_items = [{"title": "Test"}]
- source = (
- "news_items"
- if any(item.get("is_news", False) for item in news_items)
- else "research_history"
- )
- assert source == "research_history"
-
-
-# --- Subscription filter pattern ---
-
-
-class TestSubscriptionFilterPattern:
- """Tests for subscription_id filtering from api.py:139-145."""
-
- def test_all_filter_not_applied(self):
- subscription_id = "all"
- should_filter = subscription_id and subscription_id != "all"
- assert not should_filter
-
- def test_specific_id_filter_applied(self):
- subscription_id = "sub-123"
- should_filter = subscription_id and subscription_id != "all"
- assert should_filter
-
- def test_none_filter_not_applied(self):
- subscription_id = None
- should_filter = subscription_id and subscription_id != "all"
- assert not should_filter
-
- def test_empty_string_filter_not_applied(self):
- subscription_id = ""
- should_filter = subscription_id and subscription_id != "all"
- assert not should_filter
-
-
-# --- Research ID resolution ---
-
-
-class TestResearchIdResolution:
- """Tests for research ID resolution from api.py:321."""
-
- def test_uuid_id_preferred(self):
- row = {"uuid_id": "uuid-123", "id": 42}
- research_id = row.get("uuid_id") or str(row["id"])
- assert research_id == "uuid-123"
-
- def test_falls_back_to_id(self):
- row = {"uuid_id": None, "id": 42}
- research_id = row.get("uuid_id") or str(row["id"])
- assert research_id == "42"
-
- def test_id_converted_to_string(self):
- row = {"uuid_id": None, "id": 99}
- research_id = row.get("uuid_id") or str(row["id"])
- assert isinstance(research_id, str)
-
- def test_empty_uuid_falls_back(self):
- row = {"uuid_id": "", "id": 55}
- research_id = row.get("uuid_id") or str(row["id"])
- assert research_id == "55"
-
-
-# --- Status filtering ---
-
-
-class TestStatusFiltering:
- """Tests for status filtering from api.py:307-311."""
-
- def test_in_progress_filtered(self):
- status = "in_progress"
- should_skip = status in ["in_progress", "suspended"]
- assert should_skip
-
- def test_suspended_filtered(self):
- status = "suspended"
- should_skip = status in ["in_progress", "suspended"]
- assert should_skip
-
- def test_completed_not_filtered(self):
- status = "completed"
- should_skip = status in ["in_progress", "suspended"]
- assert not should_skip
-
- def test_failed_not_filtered(self):
- status = "failed"
- should_skip = status in ["in_progress", "suspended"]
- assert not should_skip
-
- def test_active_not_filtered(self):
- status = "active"
- should_skip = status in ["in_progress", "suspended"]
- assert not should_skip
diff --git a/tests/news/test_notification_patterns_behavior.py b/tests/news/test_notification_patterns_behavior.py
deleted file mode 100644
index d743ebae07..0000000000
--- a/tests/news/test_notification_patterns_behavior.py
+++ /dev/null
@@ -1,641 +0,0 @@
-"""
-Deep behavioral tests for notification patterns.
-Tests notification creation, formatting, delivery,
-batching, and preference management logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-
-
-# --- Notification creation patterns ---
-
-
-class TestNotificationCreation:
- """Tests for notification creation patterns."""
-
- def _create_notification(
- self, user_id, notification_type, content, **kwargs
- ):
- """Create a notification."""
- return {
- "id": kwargs.get(
- "id", f"notif-{user_id}-{datetime.now().timestamp()}"
- ),
- "user_id": user_id,
- "type": notification_type,
- "content": content,
- "created_at": datetime.now(timezone.utc),
- "read": False,
- "dismissed": False,
- **kwargs,
- }
-
- def test_has_id(self):
- notif = self._create_notification("user1", "news", "New article")
- assert "id" in notif
- assert notif["id"].startswith("notif-")
-
- def test_has_user_id(self):
- notif = self._create_notification("user1", "news", "New article")
- assert notif["user_id"] == "user1"
-
- def test_has_type(self):
- notif = self._create_notification("user1", "news", "New article")
- assert notif["type"] == "news"
-
- def test_has_content(self):
- notif = self._create_notification("user1", "news", "New article")
- assert notif["content"] == "New article"
-
- def test_created_at_is_now(self):
- before = datetime.now(timezone.utc)
- notif = self._create_notification("user1", "news", "New article")
- after = datetime.now(timezone.utc)
- assert before <= notif["created_at"] <= after
-
- def test_initially_unread(self):
- notif = self._create_notification("user1", "news", "New article")
- assert notif["read"] is False
-
- def test_initially_not_dismissed(self):
- notif = self._create_notification("user1", "news", "New article")
- assert notif["dismissed"] is False
-
- def test_accepts_custom_id(self):
- notif = self._create_notification(
- "user1", "news", "New article", id="custom-123"
- )
- assert notif["id"] == "custom-123"
-
-
-# --- Notification type patterns ---
-
-
-class TestNotificationTypes:
- """Tests for notification type handling."""
-
- def _is_valid_type(self, notification_type):
- """Check if notification type is valid."""
- valid_types = ["news", "subscription", "research", "system", "alert"]
- return notification_type in valid_types
-
- def test_news_valid(self):
- assert self._is_valid_type("news") is True
-
- def test_subscription_valid(self):
- assert self._is_valid_type("subscription") is True
-
- def test_research_valid(self):
- assert self._is_valid_type("research") is True
-
- def test_system_valid(self):
- assert self._is_valid_type("system") is True
-
- def test_alert_valid(self):
- assert self._is_valid_type("alert") is True
-
- def test_invalid_type(self):
- assert self._is_valid_type("unknown") is False
-
-
-class TestNotificationPriority:
- """Tests for notification priority patterns."""
-
- def _get_priority(self, notification_type):
- """Get priority for notification type."""
- priorities = {
- "alert": 1,
- "system": 2,
- "research": 3,
- "subscription": 4,
- "news": 5,
- }
- return priorities.get(notification_type, 10)
-
- def test_alert_highest_priority(self):
- assert self._get_priority("alert") == 1
-
- def test_system_high_priority(self):
- assert self._get_priority("system") == 2
-
- def test_news_lowest_priority(self):
- assert self._get_priority("news") == 5
-
- def test_unknown_type_low_priority(self):
- assert self._get_priority("unknown") == 10
-
- def test_priority_ordering(self):
- assert self._get_priority("alert") < self._get_priority("system")
- assert self._get_priority("system") < self._get_priority("news")
-
-
-# --- Notification formatting patterns ---
-
-
-class TestNotificationFormatting:
- """Tests for notification content formatting."""
-
- def _format_notification(self, notification):
- """Format notification for display."""
- title = notification.get("title", "Notification")
- content = notification.get("content", "")
- timestamp = notification.get("created_at")
- time_str = timestamp.strftime("%H:%M") if timestamp else ""
- return f"[{time_str}] {title}: {content}"
-
- def test_includes_time(self):
- notification = {
- "title": "News",
- "content": "Article",
- "created_at": datetime(2025, 6, 15, 14, 30, tzinfo=timezone.utc),
- }
- result = self._format_notification(notification)
- assert "14:30" in result
-
- def test_includes_title(self):
- notification = {
- "title": "News Alert",
- "content": "Article",
- "created_at": datetime.now(timezone.utc),
- }
- result = self._format_notification(notification)
- assert "News Alert" in result
-
- def test_includes_content(self):
- notification = {
- "title": "News",
- "content": "Important update",
- "created_at": datetime.now(timezone.utc),
- }
- result = self._format_notification(notification)
- assert "Important update" in result
-
-
-class TestNotificationTruncation:
- """Tests for notification content truncation."""
-
- def _truncate(self, content, max_length=100):
- """Truncate content to max length."""
- if not content or len(content) <= max_length:
- return content
- return content[: max_length - 3] + "..."
-
- def test_short_content_unchanged(self):
- result = self._truncate("Short text", max_length=50)
- assert result == "Short text"
-
- def test_long_content_truncated(self):
- long_text = "a" * 200
- result = self._truncate(long_text, max_length=100)
- assert len(result) == 100
- assert result.endswith("...")
-
- def test_exact_length_unchanged(self):
- text = "a" * 100
- result = self._truncate(text, max_length=100)
- assert len(result) == 100
- assert not result.endswith("...")
-
- def test_none_content(self):
- result = self._truncate(None)
- assert result is None
-
-
-# --- Read status patterns ---
-
-
-class TestReadStatusTracking:
- """Tests for notification read status tracking."""
-
- def _mark_read(self, notification):
- """Mark notification as read."""
- notification["read"] = True
- notification["read_at"] = datetime.now(timezone.utc)
- return notification
-
- def _mark_unread(self, notification):
- """Mark notification as unread."""
- notification["read"] = False
- notification.pop("read_at", None)
- return notification
-
- def test_mark_read_sets_flag(self):
- notification = {"read": False}
- result = self._mark_read(notification)
- assert result["read"] is True
-
- def test_mark_read_sets_timestamp(self):
- notification = {"read": False}
- result = self._mark_read(notification)
- assert "read_at" in result
-
- def test_mark_unread_clears_flag(self):
- notification = {"read": True, "read_at": datetime.now(timezone.utc)}
- result = self._mark_unread(notification)
- assert result["read"] is False
-
- def test_mark_unread_removes_timestamp(self):
- notification = {"read": True, "read_at": datetime.now(timezone.utc)}
- result = self._mark_unread(notification)
- assert "read_at" not in result
-
-
-class TestUnreadCount:
- """Tests for unread notification counting."""
-
- def _count_unread(self, notifications):
- """Count unread notifications."""
- return sum(1 for n in notifications if not n.get("read", False))
-
- def test_all_unread(self):
- notifications = [{"read": False}, {"read": False}, {"read": False}]
- assert self._count_unread(notifications) == 3
-
- def test_all_read(self):
- notifications = [{"read": True}, {"read": True}]
- assert self._count_unread(notifications) == 0
-
- def test_mixed(self):
- notifications = [{"read": False}, {"read": True}, {"read": False}]
- assert self._count_unread(notifications) == 2
-
- def test_empty_list(self):
- assert self._count_unread([]) == 0
-
-
-# --- Dismissal patterns ---
-
-
-class TestDismissalPatterns:
- """Tests for notification dismissal patterns."""
-
- def _dismiss(self, notification):
- """Dismiss a notification."""
- notification["dismissed"] = True
- notification["dismissed_at"] = datetime.now(timezone.utc)
- return notification
-
- def _is_visible(self, notification):
- """Check if notification should be visible."""
- return not notification.get("dismissed", False)
-
- def test_dismiss_sets_flag(self):
- notification = {"dismissed": False}
- result = self._dismiss(notification)
- assert result["dismissed"] is True
-
- def test_dismiss_sets_timestamp(self):
- notification = {"dismissed": False}
- result = self._dismiss(notification)
- assert "dismissed_at" in result
-
- def test_dismissed_not_visible(self):
- notification = {"dismissed": True}
- assert self._is_visible(notification) is False
-
- def test_not_dismissed_visible(self):
- notification = {"dismissed": False}
- assert self._is_visible(notification) is True
-
-
-# --- Batch notification patterns ---
-
-
-class TestBatchNotifications:
- """Tests for batch notification handling."""
-
- def _batch_notifications(self, notifications, batch_size=10):
- """Split notifications into batches."""
- return [
- notifications[i : i + batch_size]
- for i in range(0, len(notifications), batch_size)
- ]
-
- def test_single_batch(self):
- notifications = [{"id": i} for i in range(5)]
- batches = self._batch_notifications(notifications, batch_size=10)
- assert len(batches) == 1
- assert len(batches[0]) == 5
-
- def test_multiple_batches(self):
- notifications = [{"id": i} for i in range(25)]
- batches = self._batch_notifications(notifications, batch_size=10)
- assert len(batches) == 3
- assert len(batches[0]) == 10
- assert len(batches[1]) == 10
- assert len(batches[2]) == 5
-
- def test_empty_list(self):
- batches = self._batch_notifications([])
- assert len(batches) == 0
-
-
-class TestNotificationGrouping:
- """Tests for notification grouping patterns."""
-
- def _group_by_type(self, notifications):
- """Group notifications by type."""
- groups = {}
- for notification in notifications:
- notif_type = notification.get("type", "other")
- if notif_type not in groups:
- groups[notif_type] = []
- groups[notif_type].append(notification)
- return groups
-
- def test_groups_by_type(self):
- notifications = [
- {"type": "news", "id": 1},
- {"type": "alert", "id": 2},
- {"type": "news", "id": 3},
- ]
- groups = self._group_by_type(notifications)
- assert len(groups["news"]) == 2
- assert len(groups["alert"]) == 1
-
- def test_handles_missing_type(self):
- notifications = [{"id": 1}, {"type": "news", "id": 2}]
- groups = self._group_by_type(notifications)
- assert "other" in groups
- assert len(groups["other"]) == 1
-
-
-# --- Notification filtering patterns ---
-
-
-class TestNotificationFiltering:
- """Tests for notification filtering patterns."""
-
- def _filter_by_type(self, notifications, notification_type):
- """Filter notifications by type."""
- return [n for n in notifications if n.get("type") == notification_type]
-
- def _filter_unread(self, notifications):
- """Filter to unread notifications only."""
- return [n for n in notifications if not n.get("read", False)]
-
- def _filter_recent(self, notifications, hours=24):
- """Filter to recent notifications."""
- cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
- return [
- n for n in notifications if n.get("created_at", cutoff) >= cutoff
- ]
-
- def test_filter_by_type(self):
- notifications = [
- {"type": "news"},
- {"type": "alert"},
- {"type": "news"},
- ]
- result = self._filter_by_type(notifications, "news")
- assert len(result) == 2
-
- def test_filter_unread(self):
- notifications = [
- {"read": False},
- {"read": True},
- {"read": False},
- ]
- result = self._filter_unread(notifications)
- assert len(result) == 2
-
- def test_filter_recent(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(hours=48)
- notifications = [
- {"created_at": now},
- {"created_at": old},
- {"created_at": now},
- ]
- result = self._filter_recent(notifications, hours=24)
- assert len(result) == 2
-
-
-# --- Notification preference patterns ---
-
-
-class TestNotificationPreferences:
- """Tests for notification preference patterns."""
-
- def _get_default_preferences(self):
- """Get default notification preferences."""
- return {
- "email_enabled": True,
- "push_enabled": True,
- "types_enabled": [
- "news",
- "subscription",
- "research",
- "system",
- "alert",
- ],
- "quiet_hours_start": None,
- "quiet_hours_end": None,
- "batch_interval_minutes": 15,
- }
-
- def _should_send(self, preferences, notification_type):
- """Check if notification type should be sent."""
- if not preferences.get("email_enabled") and not preferences.get(
- "push_enabled"
- ):
- return False
- enabled_types = preferences.get("types_enabled", [])
- return notification_type in enabled_types
-
- def test_default_email_enabled(self):
- prefs = self._get_default_preferences()
- assert prefs["email_enabled"] is True
-
- def test_default_all_types_enabled(self):
- prefs = self._get_default_preferences()
- assert len(prefs["types_enabled"]) == 5
-
- def test_should_send_enabled_type(self):
- prefs = {"email_enabled": True, "types_enabled": ["news", "alert"]}
- assert self._should_send(prefs, "news") is True
-
- def test_should_not_send_disabled_type(self):
- prefs = {"email_enabled": True, "types_enabled": ["news"]}
- assert self._should_send(prefs, "alert") is False
-
- def test_should_not_send_when_all_disabled(self):
- prefs = {
- "email_enabled": False,
- "push_enabled": False,
- "types_enabled": ["news"],
- }
- assert self._should_send(prefs, "news") is False
-
-
-class TestQuietHours:
- """Tests for quiet hours patterns."""
-
- def _is_quiet_hour(self, preferences, current_hour=None):
- """Check if current time is in quiet hours."""
- start = preferences.get("quiet_hours_start")
- end = preferences.get("quiet_hours_end")
- if start is None or end is None:
- return False
- if current_hour is None:
- current_hour = datetime.now(timezone.utc).hour
- if start < end:
- return start <= current_hour < end
- # Wraps around midnight
- return current_hour >= start or current_hour < end
-
- def test_no_quiet_hours_set(self):
- prefs = {"quiet_hours_start": None, "quiet_hours_end": None}
- assert self._is_quiet_hour(prefs) is False
-
- def test_within_quiet_hours(self):
- prefs = {"quiet_hours_start": 22, "quiet_hours_end": 7}
- assert self._is_quiet_hour(prefs, current_hour=23) is True
- assert self._is_quiet_hour(prefs, current_hour=3) is True
-
- def test_outside_quiet_hours(self):
- prefs = {"quiet_hours_start": 22, "quiet_hours_end": 7}
- assert self._is_quiet_hour(prefs, current_hour=12) is False
-
- def test_daytime_quiet_hours(self):
- prefs = {"quiet_hours_start": 9, "quiet_hours_end": 17}
- assert self._is_quiet_hour(prefs, current_hour=12) is True
- assert self._is_quiet_hour(prefs, current_hour=20) is False
-
-
-# --- Notification sorting patterns ---
-
-
-class TestNotificationSorting:
- """Tests for notification sorting patterns."""
-
- def _sort_by_priority_and_time(self, notifications, get_priority):
- """Sort notifications by priority then time."""
- return sorted(
- notifications,
- key=lambda n: (
- get_priority(n.get("type", "")),
- n.get("created_at"),
- ),
- )
-
- def _sort_by_time_descending(self, notifications):
- """Sort notifications by time, newest first."""
- return sorted(
- notifications,
- key=lambda n: n.get(
- "created_at", datetime.min.replace(tzinfo=timezone.utc)
- ),
- reverse=True,
- )
-
- def test_sort_by_time_newest_first(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(hours=1)
- notifications = [
- {"id": 1, "created_at": old},
- {"id": 2, "created_at": now},
- ]
- result = self._sort_by_time_descending(notifications)
- assert result[0]["id"] == 2
-
- def test_sort_by_priority(self):
- def get_priority(t):
- return {"alert": 1, "news": 5}.get(t, 10)
-
- notifications = [
- {"type": "news", "created_at": datetime.now(timezone.utc)},
- {"type": "alert", "created_at": datetime.now(timezone.utc)},
- ]
- result = self._sort_by_priority_and_time(notifications, get_priority)
- assert result[0]["type"] == "alert"
-
-
-# --- Notification expiry patterns ---
-
-
-class TestNotificationExpiry:
- """Tests for notification expiry patterns."""
-
- def _is_expired(self, notification, max_age_days=30):
- """Check if notification has expired."""
- created_at = notification.get("created_at")
- if not created_at:
- return True
- cutoff = datetime.now(timezone.utc) - timedelta(days=max_age_days)
- return created_at < cutoff
-
- def _filter_non_expired(self, notifications, max_age_days=30):
- """Filter out expired notifications."""
- return [
- n for n in notifications if not self._is_expired(n, max_age_days)
- ]
-
- def test_recent_not_expired(self):
- notification = {"created_at": datetime.now(timezone.utc)}
- assert self._is_expired(notification) is False
-
- def test_old_is_expired(self):
- old = datetime.now(timezone.utc) - timedelta(days=60)
- notification = {"created_at": old}
- assert self._is_expired(notification) is True
-
- def test_no_timestamp_expired(self):
- notification = {}
- assert self._is_expired(notification) is True
-
- def test_filter_removes_expired(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(days=60)
- notifications = [
- {"id": 1, "created_at": now},
- {"id": 2, "created_at": old},
- ]
- result = self._filter_non_expired(notifications)
- assert len(result) == 1
- assert result[0]["id"] == 1
-
-
-# --- Notification deduplication patterns ---
-
-
-class TestNotificationDeduplication:
- """Tests for notification deduplication patterns."""
-
- def _is_duplicate(self, notification, existing, time_window_minutes=60):
- """Check if notification is a duplicate of existing."""
- if notification.get("content") != existing.get("content"):
- return False
- if notification.get("type") != existing.get("type"):
- return False
- n_time = notification.get("created_at")
- e_time = existing.get("created_at")
- if n_time and e_time:
- diff = abs((n_time - e_time).total_seconds())
- return diff < time_window_minutes * 60
- return False
-
- def test_same_content_and_type_is_duplicate(self):
- now = datetime.now(timezone.utc)
- notification = {"content": "Test", "type": "news", "created_at": now}
- existing = {"content": "Test", "type": "news", "created_at": now}
- assert self._is_duplicate(notification, existing) is True
-
- def test_different_content_not_duplicate(self):
- now = datetime.now(timezone.utc)
- notification = {"content": "Test 1", "type": "news", "created_at": now}
- existing = {"content": "Test 2", "type": "news", "created_at": now}
- assert self._is_duplicate(notification, existing) is False
-
- def test_different_type_not_duplicate(self):
- now = datetime.now(timezone.utc)
- notification = {"content": "Test", "type": "news", "created_at": now}
- existing = {"content": "Test", "type": "alert", "created_at": now}
- assert self._is_duplicate(notification, existing) is False
-
- def test_outside_time_window_not_duplicate(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(hours=2)
- notification = {"content": "Test", "type": "news", "created_at": now}
- existing = {"content": "Test", "type": "news", "created_at": old}
- assert self._is_duplicate(notification, existing) is False
diff --git a/tests/news/test_pagination_patterns_behavior.py b/tests/news/test_pagination_patterns_behavior.py
deleted file mode 100644
index a3c5af107a..0000000000
--- a/tests/news/test_pagination_patterns_behavior.py
+++ /dev/null
@@ -1,556 +0,0 @@
-"""
-Deep behavioral tests for pagination patterns.
-Tests offset pagination, cursor pagination, page calculation,
-and result windowing logic.
-"""
-
-import base64
-import json
-
-
-# --- Offset pagination patterns ---
-
-
-class TestOffsetPagination:
- """Tests for offset-based pagination."""
-
- def _calculate_offset(self, page, page_size):
- """Calculate offset for page."""
- return (max(1, page) - 1) * page_size
-
- def _calculate_page_from_offset(self, offset, page_size):
- """Calculate page number from offset."""
- if page_size <= 0:
- return 1
- return (offset // page_size) + 1
-
- def test_first_page_offset(self):
- assert self._calculate_offset(1, 10) == 0
-
- def test_second_page_offset(self):
- assert self._calculate_offset(2, 10) == 10
-
- def test_zero_page_treated_as_first(self):
- assert self._calculate_offset(0, 10) == 0
-
- def test_negative_page_treated_as_first(self):
- assert self._calculate_offset(-1, 10) == 0
-
- def test_page_from_offset(self):
- assert self._calculate_page_from_offset(0, 10) == 1
- assert self._calculate_page_from_offset(10, 10) == 2
- assert self._calculate_page_from_offset(25, 10) == 3
-
-
-class TestPageSizeValidation:
- """Tests for page size validation."""
-
- def _validate_page_size(
- self, page_size, min_size=1, max_size=100, default=20
- ):
- """Validate and normalize page size."""
- if page_size is None:
- return default
- if page_size < min_size:
- return min_size
- if page_size > max_size:
- return max_size
- return page_size
-
- def test_valid_size(self):
- assert self._validate_page_size(50) == 50
-
- def test_none_uses_default(self):
- assert self._validate_page_size(None) == 20
-
- def test_too_small_uses_min(self):
- assert self._validate_page_size(0) == 1
-
- def test_too_large_uses_max(self):
- assert self._validate_page_size(500) == 100
-
-
-# --- Total pages calculation patterns ---
-
-
-class TestTotalPagesCalculation:
- """Tests for total pages calculation."""
-
- def _calculate_total_pages(self, total_items, page_size):
- """Calculate total number of pages."""
- if page_size <= 0:
- return 0
- return (total_items + page_size - 1) // page_size
-
- def _has_next_page(self, current_page, total_pages):
- """Check if there is a next page."""
- return current_page < total_pages
-
- def _has_previous_page(self, current_page):
- """Check if there is a previous page."""
- return current_page > 1
-
- def test_exact_division(self):
- assert self._calculate_total_pages(100, 10) == 10
-
- def test_with_remainder(self):
- assert self._calculate_total_pages(101, 10) == 11
-
- def test_zero_items(self):
- assert self._calculate_total_pages(0, 10) == 0
-
- def test_has_next_page(self):
- assert self._has_next_page(1, 5) is True
- assert self._has_next_page(5, 5) is False
-
- def test_has_previous_page(self):
- assert self._has_previous_page(1) is False
- assert self._has_previous_page(2) is True
-
-
-# --- Page range calculation patterns ---
-
-
-class TestPageRangeCalculation:
- """Tests for calculating visible page ranges."""
-
- def _calculate_page_range(self, current_page, total_pages, window_size=5):
- """Calculate range of pages to display."""
- half_window = window_size // 2
- start = max(1, current_page - half_window)
- end = min(total_pages, start + window_size - 1)
- # Adjust start if end is at max
- start = max(1, end - window_size + 1)
- return list(range(start, end + 1))
-
- def test_middle_page(self):
- pages = self._calculate_page_range(5, 10, window_size=5)
- assert pages == [3, 4, 5, 6, 7]
-
- def test_first_page(self):
- pages = self._calculate_page_range(1, 10, window_size=5)
- assert pages == [1, 2, 3, 4, 5]
-
- def test_last_page(self):
- pages = self._calculate_page_range(10, 10, window_size=5)
- assert pages == [6, 7, 8, 9, 10]
-
- def test_few_pages(self):
- pages = self._calculate_page_range(2, 3, window_size=5)
- assert pages == [1, 2, 3]
-
-
-# --- Pagination result building patterns ---
-
-
-class TestPaginationResultBuilding:
- """Tests for building pagination result objects."""
-
- def _build_pagination_info(self, items, page, page_size, total_count):
- """Build pagination info object."""
- total_pages = (
- (total_count + page_size - 1) // page_size if page_size > 0 else 0
- )
- return {
- "items": items,
- "pagination": {
- "page": page,
- "page_size": page_size,
- "total_items": total_count,
- "total_pages": total_pages,
- "has_next": page < total_pages,
- "has_previous": page > 1,
- },
- }
-
- def test_includes_items(self):
- result = self._build_pagination_info([1, 2, 3], 1, 10, 100)
- assert result["items"] == [1, 2, 3]
-
- def test_includes_page_info(self):
- result = self._build_pagination_info([], 2, 10, 100)
- assert result["pagination"]["page"] == 2
- assert result["pagination"]["page_size"] == 10
-
- def test_includes_total_info(self):
- result = self._build_pagination_info([], 1, 10, 100)
- assert result["pagination"]["total_items"] == 100
- assert result["pagination"]["total_pages"] == 10
-
- def test_includes_navigation_flags(self):
- result = self._build_pagination_info([], 5, 10, 100)
- assert result["pagination"]["has_next"] is True
- assert result["pagination"]["has_previous"] is True
-
-
-# --- Cursor pagination patterns ---
-
-
-class TestCursorPagination:
- """Tests for cursor-based pagination."""
-
- def _encode_cursor(self, data):
- """Encode data into cursor string."""
- json_str = json.dumps(data, default=str)
- return base64.b64encode(json_str.encode()).decode()
-
- def _decode_cursor(self, cursor):
- """Decode cursor string into data."""
- try:
- json_str = base64.b64decode(cursor.encode()).decode()
- return json.loads(json_str)
- except Exception:
- return None
-
- def _build_cursor_response(self, items, cursor_field, has_more=True):
- """Build cursor-based pagination response."""
- if not items:
- return {"items": [], "next_cursor": None, "has_more": False}
- last_item = items[-1]
- cursor_value = last_item.get(cursor_field)
- cursor = self._encode_cursor(
- {"v": cursor_value, "id": last_item.get("id")}
- )
- return {
- "items": items,
- "next_cursor": cursor if has_more else None,
- "has_more": has_more,
- }
-
- def test_encode_decode_roundtrip(self):
- original = {"v": "2025-01-01", "id": 123}
- cursor = self._encode_cursor(original)
- decoded = self._decode_cursor(cursor)
- assert decoded == original
-
- def test_cursor_response_with_items(self):
- items = [
- {"id": 1, "created_at": "2025-01-01"},
- {"id": 2, "created_at": "2025-01-02"},
- ]
- response = self._build_cursor_response(items, "created_at")
- assert response["next_cursor"] is not None
- assert response["has_more"] is True
-
- def test_cursor_response_empty(self):
- response = self._build_cursor_response([], "created_at")
- assert response["next_cursor"] is None
- assert response["has_more"] is False
-
-
-class TestCursorComparison:
- """Tests for cursor comparison logic."""
-
- def _compare_by_cursor(
- self, item, cursor_data, sort_field, direction="asc"
- ):
- """Check if item comes after cursor position."""
- item_value = item.get(sort_field)
- cursor_value = cursor_data.get("v")
- if direction == "asc":
- return item_value > cursor_value
- return item_value < cursor_value
-
- def test_after_cursor_asc(self):
- item = {"created_at": "2025-01-02"}
- cursor = {"v": "2025-01-01"}
- assert (
- self._compare_by_cursor(item, cursor, "created_at", "asc") is True
- )
-
- def test_before_cursor_asc(self):
- item = {"created_at": "2025-01-01"}
- cursor = {"v": "2025-01-02"}
- assert (
- self._compare_by_cursor(item, cursor, "created_at", "asc") is False
- )
-
- def test_after_cursor_desc(self):
- item = {"created_at": "2025-01-01"}
- cursor = {"v": "2025-01-02"}
- assert (
- self._compare_by_cursor(item, cursor, "created_at", "desc") is True
- )
-
-
-# --- Keyset pagination patterns ---
-
-
-class TestKeysetPagination:
- """Tests for keyset pagination patterns."""
-
- def _build_keyset_cursor(self, sort_values, item_id):
- """Build keyset cursor from multiple sort values."""
- return self._encode_keyset({"sorts": sort_values, "id": item_id})
-
- def _encode_keyset(self, data):
- """Encode keyset data."""
- json_str = json.dumps(data, default=str)
- return base64.b64encode(json_str.encode()).decode()
-
- def _decode_keyset(self, cursor):
- """Decode keyset cursor."""
- try:
- json_str = base64.b64decode(cursor.encode()).decode()
- return json.loads(json_str)
- except Exception:
- return None
-
- def test_keyset_with_multiple_sorts(self):
- cursor = self._build_keyset_cursor(
- {"created_at": "2025-01-01", "score": 95}, "id123"
- )
- decoded = self._decode_keyset(cursor)
- assert decoded["sorts"]["created_at"] == "2025-01-01"
- assert decoded["sorts"]["score"] == 95
- assert decoded["id"] == "id123"
-
-
-# --- Infinite scroll patterns ---
-
-
-class TestInfiniteScrollPagination:
- """Tests for infinite scroll pagination patterns."""
-
- def _build_infinite_scroll_response(
- self, items, page_size, total_remaining=None
- ):
- """Build infinite scroll response."""
- return {
- "items": items,
- "load_more": len(items) >= page_size,
- "remaining": total_remaining,
- }
-
- def _should_preload_next(
- self, scroll_position, content_height, threshold=0.8
- ):
- """Check if next page should be preloaded."""
- if content_height <= 0:
- return False
- scroll_ratio = scroll_position / content_height
- return scroll_ratio >= threshold
-
- def test_full_page_has_load_more(self):
- response = self._build_infinite_scroll_response([1, 2, 3], page_size=3)
- assert response["load_more"] is True
-
- def test_partial_page_no_load_more(self):
- response = self._build_infinite_scroll_response([1, 2], page_size=3)
- assert response["load_more"] is False
-
- def test_preload_threshold_reached(self):
- assert self._should_preload_next(800, 1000, threshold=0.8) is True
-
- def test_preload_threshold_not_reached(self):
- assert self._should_preload_next(500, 1000, threshold=0.8) is False
-
-
-# --- Page link building patterns ---
-
-
-class TestPageLinkBuilding:
- """Tests for building pagination links."""
-
- def _build_page_link(self, base_url, page, page_size, **extra_params):
- """Build URL for a specific page."""
- params = {"page": page, "page_size": page_size}
- params.update(extra_params)
- param_str = "&".join(f"{k}={v}" for k, v in params.items())
- return f"{base_url}?{param_str}"
-
- def _build_pagination_links(
- self, base_url, current_page, total_pages, page_size
- ):
- """Build all pagination links."""
- links = {
- "self": self._build_page_link(base_url, current_page, page_size)
- }
- if current_page > 1:
- links["first"] = self._build_page_link(base_url, 1, page_size)
- links["prev"] = self._build_page_link(
- base_url, current_page - 1, page_size
- )
- if current_page < total_pages:
- links["next"] = self._build_page_link(
- base_url, current_page + 1, page_size
- )
- links["last"] = self._build_page_link(
- base_url, total_pages, page_size
- )
- return links
-
- def test_page_link_format(self):
- link = self._build_page_link("/api/items", 2, 10)
- assert "page=2" in link
- assert "page_size=10" in link
-
- def test_pagination_links_middle_page(self):
- links = self._build_pagination_links("/api/items", 5, 10, 10)
- assert "self" in links
- assert "first" in links
- assert "prev" in links
- assert "next" in links
- assert "last" in links
-
- def test_pagination_links_first_page(self):
- links = self._build_pagination_links("/api/items", 1, 10, 10)
- assert "prev" not in links
- assert "first" not in links
- assert "next" in links
-
-
-# --- Result windowing patterns ---
-
-
-class TestResultWindowing:
- """Tests for result windowing patterns."""
-
- def _window_results(self, results, start, count):
- """Get a window of results."""
- return results[start : start + count]
-
- def _sliding_window(self, results, window_size, overlap=0):
- """Generate sliding windows of results."""
- windows = []
- step = window_size - overlap
- for i in range(0, len(results), step):
- window = results[i : i + window_size]
- if window:
- windows.append(window)
- return windows
-
- def test_window_from_start(self):
- results = [1, 2, 3, 4, 5]
- window = self._window_results(results, 0, 3)
- assert window == [1, 2, 3]
-
- def test_window_from_middle(self):
- results = [1, 2, 3, 4, 5]
- window = self._window_results(results, 2, 2)
- assert window == [3, 4]
-
- def test_sliding_windows_no_overlap(self):
- results = list(range(10))
- windows = self._sliding_window(results, 3, overlap=0)
- assert len(windows) == 4 # [0,1,2], [3,4,5], [6,7,8], [9]
-
- def test_sliding_windows_with_overlap(self):
- results = list(range(6))
- windows = self._sliding_window(results, 3, overlap=1)
- # [0,1,2], [2,3,4], [4,5]
- assert len(windows) == 3
- assert windows[0] == [0, 1, 2]
- assert windows[1] == [2, 3, 4]
-
-
-# --- Empty result handling patterns ---
-
-
-class TestEmptyResultHandling:
- """Tests for handling empty paginated results."""
-
- def _build_empty_response(self, page, page_size, total=0):
- """Build response for empty results."""
- return {
- "items": [],
- "pagination": {
- "page": page,
- "page_size": page_size,
- "total_items": total,
- "total_pages": 0,
- "has_next": False,
- "has_previous": page > 1,
- },
- }
-
- def _is_beyond_range(self, page, total_pages):
- """Check if page is beyond available range."""
- return page > max(1, total_pages)
-
- def test_empty_response_structure(self):
- response = self._build_empty_response(1, 10)
- assert response["items"] == []
- assert response["pagination"]["total_pages"] == 0
-
- def test_beyond_range_check(self):
- assert self._is_beyond_range(5, 3) is True
- assert self._is_beyond_range(2, 3) is False
- assert (
- self._is_beyond_range(1, 0) is False
- ) # Page 1 is valid even with 0 pages
-
-
-# --- Batch pagination patterns ---
-
-
-class TestBatchPagination:
- """Tests for batch-based pagination patterns."""
-
- def _paginate_batch(
- self, batch, batch_number, items_per_batch, items_per_page
- ):
- """Get a specific page from a batch."""
- batch_start = batch_number * items_per_batch
- pages_per_batch = items_per_batch // items_per_page
- return {
- "batch": batch_number,
- "pages_in_batch": pages_per_batch,
- "first_item_index": batch_start,
- }
-
- def _calculate_batch_for_page(self, page, items_per_page, items_per_batch):
- """Calculate which batch contains a page."""
- item_index = (page - 1) * items_per_page
- return item_index // items_per_batch
-
- def test_batch_info(self):
- info = self._paginate_batch(None, 0, 100, 10)
- assert info["batch"] == 0
- assert info["pages_in_batch"] == 10
- assert info["first_item_index"] == 0
-
- def test_batch_for_page(self):
- batch = self._calculate_batch_for_page(1, 10, 100)
- assert batch == 0
- batch = self._calculate_batch_for_page(11, 10, 100)
- assert batch == 1
-
-
-# --- Seek pagination patterns ---
-
-
-class TestSeekPagination:
- """Tests for seek-based pagination patterns."""
-
- def _build_seek_condition(self, last_id, direction="forward"):
- """Build seek condition based on last seen ID."""
- if direction == "forward":
- return f"id > {last_id}"
- return f"id < {last_id}"
-
- def _extract_seek_id(self, items, position="last"):
- """Extract ID for seeking from items."""
- if not items:
- return None
- if position == "last":
- return items[-1].get("id")
- return items[0].get("id")
-
- def test_forward_seek(self):
- condition = self._build_seek_condition(100, "forward")
- assert condition == "id > 100"
-
- def test_backward_seek(self):
- condition = self._build_seek_condition(100, "backward")
- assert condition == "id < 100"
-
- def test_extract_last_id(self):
- items = [{"id": 1}, {"id": 2}, {"id": 3}]
- last_id = self._extract_seek_id(items, "last")
- assert last_id == 3
-
- def test_extract_first_id(self):
- items = [{"id": 1}, {"id": 2}, {"id": 3}]
- first_id = self._extract_seek_id(items, "first")
- assert first_id == 1
diff --git a/tests/news/test_preference_storage_logic_behavior.py b/tests/news/test_preference_storage_logic_behavior.py
deleted file mode 100644
index c73744d937..0000000000
--- a/tests/news/test_preference_storage_logic_behavior.py
+++ /dev/null
@@ -1,392 +0,0 @@
-"""
-Deep behavioral tests for preference_manager/storage.py pure logic.
-Tests upsert patterns, liked/disliked list management, list capping,
-and embedding handling patterns.
-"""
-
-
-# --- Create defaults ---
-
-
-class TestPreferenceCreateDefaults:
- """Tests for preference creation default values."""
-
- def _apply_defaults(self, data):
- return {
- "user_id": data["user_id"],
- "liked_categories": data.get("liked_categories", []),
- "disliked_categories": data.get("disliked_categories", []),
- "liked_topics": data.get("liked_topics", []),
- "disliked_topics": data.get("disliked_topics", []),
- "impact_threshold": data.get("impact_threshold", 5),
- "focus_preferences": data.get("focus_preferences", {}),
- "custom_prompt": data.get("custom_prompt"),
- "custom_search_terms": data.get("custom_search_terms"),
- "preference_embedding": data.get("preference_embedding"),
- "liked_news_ids": data.get("liked_news_ids", []),
- "disliked_news_ids": data.get("disliked_news_ids", []),
- }
-
- def test_liked_categories_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["liked_categories"] == []
-
- def test_disliked_categories_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["disliked_categories"] == []
-
- def test_liked_topics_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["liked_topics"] == []
-
- def test_disliked_topics_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["disliked_topics"] == []
-
- def test_impact_threshold_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["impact_threshold"] == 5
-
- def test_focus_preferences_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["focus_preferences"] == {}
-
- def test_custom_prompt_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["custom_prompt"] is None
-
- def test_liked_news_ids_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["liked_news_ids"] == []
-
- def test_disliked_news_ids_default(self):
- result = self._apply_defaults({"user_id": "u1"})
- assert result["disliked_news_ids"] == []
-
- def test_custom_values_preserved(self):
- data = {
- "user_id": "u1",
- "liked_categories": ["Tech", "Science"],
- "impact_threshold": 8,
- }
- result = self._apply_defaults(data)
- assert result["liked_categories"] == ["Tech", "Science"]
- assert result["impact_threshold"] == 8
-
-
-# --- Upsert logic ---
-
-
-class TestUpsertLogic:
- """Tests for create-or-update preference logic."""
-
- def _should_update(self, existing):
- return existing is not None
-
- def test_update_when_exists(self):
- existing = {"id": 1, "user_id": "u1"}
- assert self._should_update(existing) is True
-
- def test_create_when_none(self):
- assert self._should_update(None) is False
-
- def test_create_when_empty_dict(self):
- # Empty dict is truthy
- assert self._should_update({}) is True
-
-
-class TestUpsertUserIdHandling:
- """Tests for user_id handling in upsert."""
-
- def _prepare_create_data(self, user_id, preferences):
- preferences["user_id"] = user_id
- return preferences
-
- def test_adds_user_id(self):
- result = self._prepare_create_data("u1", {"liked_topics": ["AI"]})
- assert result["user_id"] == "u1"
-
- def test_overwrites_existing_user_id(self):
- result = self._prepare_create_data("u1", {"user_id": "old"})
- assert result["user_id"] == "u1"
-
-
-# --- Liked/disliked list management ---
-
-
-class TestLikedListManagement:
- """Tests for adding items to liked list."""
-
- def _add_to_list(self, current_list, item_id, max_items=100):
- if current_list is None:
- current_list = []
- if item_id not in current_list:
- current_list.append(item_id)
- current_list = current_list[-max_items:]
- return current_list
-
- def test_add_first_item(self):
- result = self._add_to_list([], "item1")
- assert result == ["item1"]
-
- def test_add_to_none(self):
- result = self._add_to_list(None, "item1")
- assert result == ["item1"]
-
- def test_add_second_item(self):
- result = self._add_to_list(["item1"], "item2")
- assert result == ["item1", "item2"]
-
- def test_no_duplicate(self):
- result = self._add_to_list(["item1"], "item1")
- assert result == ["item1"]
-
- def test_max_100_items(self):
- current = [f"item{i}" for i in range(100)]
- result = self._add_to_list(current, "item100")
- assert len(result) == 100
- assert result[0] == "item1" # First item removed
- assert result[-1] == "item100"
-
- def test_keeps_last_100(self):
- current = [f"item{i}" for i in range(150)]
- result = self._add_to_list(current, "item150", max_items=100)
- assert len(result) == 100
- assert result[-1] == "item150"
-
-
-class TestDislikedListManagement:
- """Tests for adding items to disliked list."""
-
- def _add_disliked(self, current, item_id, item_type="news", max_items=100):
- if item_type != "news":
- return current
- if current is None:
- current = []
- if item_id not in current:
- current.append(item_id)
- return current[-max_items:]
- return current
-
- def test_add_news_item(self):
- result = self._add_disliked([], "n1", "news")
- assert result == ["n1"]
-
- def test_ignore_non_news_type(self):
- result = self._add_disliked([], "c1", "card")
- assert result == []
-
- def test_no_duplicate_disliked(self):
- result = self._add_disliked(["n1"], "n1", "news")
- assert result == ["n1"]
-
-
-# --- Item type checking ---
-
-
-class TestItemTypeChecking:
- """Tests for item_type validation."""
-
- def _is_news_item(self, item_type):
- return item_type == "news"
-
- def test_news_type(self):
- assert self._is_news_item("news") is True
-
- def test_card_type(self):
- assert self._is_news_item("card") is False
-
- def test_other_type(self):
- assert self._is_news_item("other") is False
-
- def test_empty_type(self):
- assert self._is_news_item("") is False
-
-
-# --- Embedding handling ---
-
-
-class TestEmbeddingHandling:
- """Tests for preference embedding patterns."""
-
- def _update_embedding(self, existing_prefs, embedding):
- if existing_prefs is None:
- return {"preference_embedding": embedding}
- existing_prefs["preference_embedding"] = embedding
- return existing_prefs
-
- def test_set_embedding_on_none(self):
- result = self._update_embedding(None, [0.1, 0.2, 0.3])
- assert result["preference_embedding"] == [0.1, 0.2, 0.3]
-
- def test_update_existing_embedding(self):
- prefs = {"user_id": "u1", "preference_embedding": [0.0]}
- result = self._update_embedding(prefs, [1.0, 2.0])
- assert result["preference_embedding"] == [1.0, 2.0]
-
- def test_preserves_other_fields(self):
- prefs = {"user_id": "u1", "liked_topics": ["AI"]}
- result = self._update_embedding(prefs, [0.5])
- assert result["user_id"] == "u1"
- assert result["liked_topics"] == ["AI"]
-
-
-# --- Update field validation ---
-
-
-class TestUpdateFieldValidation:
- """Tests for update field validation patterns."""
-
- VALID_FIELDS = {
- "liked_categories",
- "disliked_categories",
- "liked_topics",
- "disliked_topics",
- "impact_threshold",
- "focus_preferences",
- "custom_prompt",
- "custom_search_terms",
- "preference_embedding",
- }
-
- def _is_valid_field(self, field):
- return field in self.VALID_FIELDS
-
- def test_liked_categories_valid(self):
- assert self._is_valid_field("liked_categories") is True
-
- def test_impact_threshold_valid(self):
- assert self._is_valid_field("impact_threshold") is True
-
- def test_preference_embedding_valid(self):
- assert self._is_valid_field("preference_embedding") is True
-
- def test_user_id_not_valid_for_update(self):
- assert self._is_valid_field("user_id") is False
-
- def test_id_not_valid_for_update(self):
- assert self._is_valid_field("id") is False
-
-
-# --- Create preferences for liked/disliked item ---
-
-
-class TestCreatePrefsForLikedItem:
- """Tests for creating prefs when adding liked item."""
-
- def _create_for_liked(self, user_id, item_id, item_type):
- return {
- "user_id": user_id,
- "liked_news_ids": [item_id] if item_type == "news" else [],
- "disliked_news_ids": [],
- }
-
- def test_creates_with_liked_id(self):
- result = self._create_for_liked("u1", "n1", "news")
- assert result["liked_news_ids"] == ["n1"]
- assert result["disliked_news_ids"] == []
-
- def test_non_news_type(self):
- result = self._create_for_liked("u1", "c1", "card")
- assert result["liked_news_ids"] == []
-
-
-class TestCreatePrefsForDislikedItem:
- """Tests for creating prefs when adding disliked item."""
-
- def _create_for_disliked(self, user_id, item_id, item_type):
- return {
- "user_id": user_id,
- "liked_news_ids": [],
- "disliked_news_ids": [item_id] if item_type == "news" else [],
- }
-
- def test_creates_with_disliked_id(self):
- result = self._create_for_disliked("u1", "n1", "news")
- assert result["disliked_news_ids"] == ["n1"]
- assert result["liked_news_ids"] == []
-
-
-# --- List filtering ---
-
-
-class TestListFiltering:
- """Tests for preference list filtering patterns."""
-
- def _should_filter_user(self, filters):
- return filters and "user_id" in filters
-
- def test_filter_by_user(self):
- assert self._should_filter_user({"user_id": "u1"}) is True
-
- def test_no_filter(self):
- assert not self._should_filter_user(None)
-
- def test_empty_filter(self):
- assert not self._should_filter_user({})
-
-
-# --- ID conversion ---
-
-
-class TestIdConversion:
- """Tests for ID type conversion patterns."""
-
- def _to_int_id(self, id_str):
- return int(id_str)
-
- def test_string_to_int(self):
- assert self._to_int_id("123") == 123
-
- def test_numeric_string(self):
- assert self._to_int_id("0") == 0
-
- def test_large_id(self):
- assert self._to_int_id("999999") == 999999
-
-
-# --- Preference dict structure ---
-
-
-class TestPreferenceDictStructure:
- """Tests for preference dict expected fields."""
-
- EXPECTED_FIELDS = [
- "id",
- "user_id",
- "liked_categories",
- "disliked_categories",
- "liked_topics",
- "disliked_topics",
- "impact_threshold",
- "focus_preferences",
- "custom_prompt",
- "custom_search_terms",
- "preference_embedding",
- "liked_news_ids",
- "disliked_news_ids",
- ]
-
- def test_has_id(self):
- assert "id" in self.EXPECTED_FIELDS
-
- def test_has_user_id(self):
- assert "user_id" in self.EXPECTED_FIELDS
-
- def test_has_liked_categories(self):
- assert "liked_categories" in self.EXPECTED_FIELDS
-
- def test_has_disliked_categories(self):
- assert "disliked_categories" in self.EXPECTED_FIELDS
-
- def test_has_impact_threshold(self):
- assert "impact_threshold" in self.EXPECTED_FIELDS
-
- def test_has_preference_embedding(self):
- assert "preference_embedding" in self.EXPECTED_FIELDS
-
- def test_has_liked_news_ids(self):
- assert "liked_news_ids" in self.EXPECTED_FIELDS
-
- def test_has_disliked_news_ids(self):
- assert "disliked_news_ids" in self.EXPECTED_FIELDS
diff --git a/tests/news/test_query_building_patterns_behavior.py b/tests/news/test_query_building_patterns_behavior.py
deleted file mode 100644
index f263a887dc..0000000000
--- a/tests/news/test_query_building_patterns_behavior.py
+++ /dev/null
@@ -1,580 +0,0 @@
-"""
-Deep behavioral tests for query building patterns.
-Tests SQL query construction, filter building,
-sort ordering, and pagination query logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-
-
-# --- Basic query builder patterns ---
-
-
-class TestBasicQueryBuilder:
- """Tests for basic query builder patterns."""
-
- def _build_select(self, table, columns=None):
- """Build a SELECT query."""
- cols = ", ".join(columns) if columns else "*"
- return f"SELECT {cols} FROM {table}"
-
- def _add_where(self, query, conditions):
- """Add WHERE clause to query."""
- if not conditions:
- return query
- where_str = " AND ".join(conditions)
- return f"{query} WHERE {where_str}"
-
- def test_select_all(self):
- query = self._build_select("users")
- assert query == "SELECT * FROM users"
-
- def test_select_columns(self):
- query = self._build_select("users", ["id", "name"])
- assert query == "SELECT id, name FROM users"
-
- def test_add_single_where(self):
- query = self._build_select("users")
- query = self._add_where(query, ["active = 1"])
- assert "WHERE active = 1" in query
-
- def test_add_multiple_where(self):
- query = self._build_select("users")
- query = self._add_where(query, ["active = 1", "role = 'admin'"])
- assert "WHERE active = 1 AND role = 'admin'" in query
-
-
-class TestParameterizedQuery:
- """Tests for parameterized query building."""
-
- def _build_parameterized(self, template, params):
- """Build parameterized query (for display only)."""
- return {"query": template, "params": params}
-
- def _count_placeholders(self, query):
- """Count placeholders in query."""
- return query.count("?")
-
- def test_single_param(self):
- result = self._build_parameterized(
- "SELECT * FROM users WHERE id = ?", [123]
- )
- assert result["query"] == "SELECT * FROM users WHERE id = ?"
- assert result["params"] == [123]
-
- def test_multiple_params(self):
- result = self._build_parameterized(
- "SELECT * FROM users WHERE status = ? AND role = ?",
- ["active", "admin"],
- )
- assert len(result["params"]) == 2
-
- def test_count_placeholders(self):
- query = "SELECT * FROM t WHERE a = ? AND b = ? AND c = ?"
- assert self._count_placeholders(query) == 3
-
-
-# --- Filter building patterns ---
-
-
-class TestFilterBuilder:
- """Tests for filter building patterns."""
-
- def _build_filter(self, field, operator, value):
- """Build a single filter condition."""
- if operator == "eq":
- return f"{field} = ?", [value]
- if operator == "ne":
- return f"{field} != ?", [value]
- if operator == "gt":
- return f"{field} > ?", [value]
- if operator == "gte":
- return f"{field} >= ?", [value]
- if operator == "lt":
- return f"{field} < ?", [value]
- if operator == "lte":
- return f"{field} <= ?", [value]
- if operator == "like":
- return f"{field} LIKE ?", [f"%{value}%"]
- if operator == "in":
- placeholders = ", ".join(["?"] * len(value))
- return f"{field} IN ({placeholders})", value
- return None, []
-
- def test_equals_filter(self):
- condition, params = self._build_filter("status", "eq", "active")
- assert condition == "status = ?"
- assert params == ["active"]
-
- def test_greater_than_filter(self):
- condition, params = self._build_filter("score", "gt", 50)
- assert condition == "score > ?"
- assert params == [50]
-
- def test_like_filter(self):
- condition, params = self._build_filter("name", "like", "john")
- assert condition == "name LIKE ?"
- assert params == ["%john%"]
-
- def test_in_filter(self):
- condition, params = self._build_filter("id", "in", [1, 2, 3])
- assert "IN (?, ?, ?)" in condition
- assert params == [1, 2, 3]
-
-
-class TestDateRangeFilter:
- """Tests for date range filter building."""
-
- def _build_date_range(self, field, start=None, end=None):
- """Build date range filter."""
- conditions = []
- params = []
- if start:
- conditions.append(f"{field} >= ?")
- params.append(start)
- if end:
- conditions.append(f"{field} <= ?")
- params.append(end)
- return conditions, params
-
- def _build_relative_date(self, field, days_ago):
- """Build filter for relative date."""
- cutoff = datetime.now(timezone.utc) - timedelta(days=days_ago)
- return f"{field} >= ?", [cutoff]
-
- def test_start_only(self):
- start = datetime(2025, 1, 1, tzinfo=timezone.utc)
- conditions, params = self._build_date_range("created_at", start=start)
- assert len(conditions) == 1
- assert "created_at >= ?" in conditions[0]
-
- def test_end_only(self):
- end = datetime(2025, 12, 31, tzinfo=timezone.utc)
- conditions, params = self._build_date_range("created_at", end=end)
- assert len(conditions) == 1
- assert "created_at <= ?" in conditions[0]
-
- def test_both_bounds(self):
- start = datetime(2025, 1, 1, tzinfo=timezone.utc)
- end = datetime(2025, 12, 31, tzinfo=timezone.utc)
- conditions, params = self._build_date_range(
- "created_at", start=start, end=end
- )
- assert len(conditions) == 2
- assert len(params) == 2
-
-
-# --- Sort building patterns ---
-
-
-class TestSortBuilder:
- """Tests for sort clause building."""
-
- def _build_order_by(self, sort_fields):
- """Build ORDER BY clause."""
- if not sort_fields:
- return ""
- parts = []
- for field in sort_fields:
- if field.startswith("-"):
- parts.append(f"{field[1:]} DESC")
- else:
- parts.append(f"{field} ASC")
- return "ORDER BY " + ", ".join(parts)
-
- def _parse_sort_string(self, sort_str):
- """Parse sort string into fields."""
- if not sort_str:
- return []
- return [s.strip() for s in sort_str.split(",")]
-
- def test_single_asc(self):
- order = self._build_order_by(["name"])
- assert order == "ORDER BY name ASC"
-
- def test_single_desc(self):
- order = self._build_order_by(["-created_at"])
- assert order == "ORDER BY created_at DESC"
-
- def test_multiple_sort(self):
- order = self._build_order_by(["status", "-created_at"])
- assert "status ASC" in order
- assert "created_at DESC" in order
-
- def test_empty_sort(self):
- order = self._build_order_by([])
- assert order == ""
-
- def test_parse_sort_string(self):
- fields = self._parse_sort_string("-created_at, name")
- assert fields == ["-created_at", "name"]
-
-
-# --- Pagination patterns ---
-
-
-class TestPaginationQuery:
- """Tests for pagination query building."""
-
- def _build_pagination(self, page, page_size):
- """Build LIMIT/OFFSET clause."""
- offset = (page - 1) * page_size
- return f"LIMIT {page_size} OFFSET {offset}"
-
- def _calculate_total_pages(self, total_count, page_size):
- """Calculate total pages."""
- if page_size <= 0:
- return 0
- return (total_count + page_size - 1) // page_size
-
- def test_first_page(self):
- clause = self._build_pagination(page=1, page_size=10)
- assert clause == "LIMIT 10 OFFSET 0"
-
- def test_second_page(self):
- clause = self._build_pagination(page=2, page_size=10)
- assert clause == "LIMIT 10 OFFSET 10"
-
- def test_total_pages_exact(self):
- pages = self._calculate_total_pages(100, 10)
- assert pages == 10
-
- def test_total_pages_remainder(self):
- pages = self._calculate_total_pages(101, 10)
- assert pages == 11
-
-
-class TestCursorPagination:
- """Tests for cursor-based pagination."""
-
- def _encode_cursor(self, sort_value, item_id):
- """Encode cursor from sort value and ID."""
- import base64
-
- cursor_str = f"{sort_value}:{item_id}"
- return base64.b64encode(cursor_str.encode()).decode()
-
- def _decode_cursor(self, cursor):
- """Decode cursor to sort value and ID."""
- import base64
-
- try:
- decoded = base64.b64decode(cursor.encode()).decode()
- sort_value, item_id = decoded.rsplit(":", 1)
- return sort_value, item_id
- except Exception:
- return None, None
-
- def _build_cursor_condition(self, cursor, sort_field, direction="asc"):
- """Build WHERE condition for cursor pagination."""
- sort_value, item_id = self._decode_cursor(cursor)
- if sort_value is None:
- return None, []
- op = ">" if direction == "asc" else "<"
- condition = f"({sort_field} {op} ? OR ({sort_field} = ? AND id {op} ?))"
- return condition, [sort_value, sort_value, item_id]
-
- def test_encode_decode_roundtrip(self):
- cursor = self._encode_cursor("2025-01-01", "123")
- sort_value, item_id = self._decode_cursor(cursor)
- assert sort_value == "2025-01-01"
- assert item_id == "123"
-
- def test_build_cursor_condition(self):
- cursor = self._encode_cursor("value", "id123")
- condition, params = self._build_cursor_condition(cursor, "created_at")
- assert condition is not None
- assert len(params) == 3
-
-
-# --- Join building patterns ---
-
-
-class TestJoinBuilder:
- """Tests for JOIN clause building."""
-
- def _build_join(self, join_type, table, condition):
- """Build a JOIN clause."""
- return f"{join_type} JOIN {table} ON {condition}"
-
- def _build_inner_join(self, table, left_col, right_col):
- """Build INNER JOIN."""
- return f"INNER JOIN {table} ON {left_col} = {right_col}"
-
- def _build_left_join(self, table, left_col, right_col):
- """Build LEFT JOIN."""
- return f"LEFT JOIN {table} ON {left_col} = {right_col}"
-
- def test_inner_join(self):
- join = self._build_inner_join("orders", "users.id", "orders.user_id")
- assert "INNER JOIN orders ON users.id = orders.user_id" == join
-
- def test_left_join(self):
- join = self._build_left_join("profiles", "users.id", "profiles.user_id")
- assert "LEFT JOIN profiles ON users.id = profiles.user_id" == join
-
- def test_custom_join(self):
- join = self._build_join("RIGHT", "items", "orders.id = items.order_id")
- assert "RIGHT JOIN items ON orders.id = items.order_id" == join
-
-
-# --- Aggregate query patterns ---
-
-
-class TestAggregateQuery:
- """Tests for aggregate query building."""
-
- def _build_count(self, table, column="*"):
- """Build COUNT query."""
- return f"SELECT COUNT({column}) FROM {table}"
-
- def _build_aggregate(self, table, function, column):
- """Build aggregate query."""
- return f"SELECT {function}({column}) FROM {table}"
-
- def _build_group_by(self, query, columns):
- """Add GROUP BY to query."""
- return f"{query} GROUP BY {', '.join(columns)}"
-
- def test_count_all(self):
- query = self._build_count("users")
- assert query == "SELECT COUNT(*) FROM users"
-
- def test_count_column(self):
- query = self._build_count("users", "email")
- assert query == "SELECT COUNT(email) FROM users"
-
- def test_sum_aggregate(self):
- query = self._build_aggregate("orders", "SUM", "amount")
- assert query == "SELECT SUM(amount) FROM orders"
-
- def test_avg_aggregate(self):
- query = self._build_aggregate("products", "AVG", "price")
- assert query == "SELECT AVG(price) FROM products"
-
- def test_group_by(self):
- query = self._build_count("orders")
- query = self._build_group_by(query, ["status", "user_id"])
- assert "GROUP BY status, user_id" in query
-
-
-# --- Search query patterns ---
-
-
-class TestSearchQuery:
- """Tests for full-text search query building."""
-
- def _build_text_search(self, columns, search_term):
- """Build text search condition."""
- conditions = [f"{col} LIKE ?" for col in columns]
- params = [f"%{search_term}%"] * len(columns)
- return "(" + " OR ".join(conditions) + ")", params
-
- def _escape_search_term(self, term):
- """Escape special characters in search term."""
- special_chars = ["%", "_", "[", "]"]
- for char in special_chars:
- term = term.replace(char, f"\\{char}")
- return term
-
- def _tokenize_search(self, search_string):
- """Tokenize search string into terms."""
- # Simple tokenization: split on whitespace, filter empty
- return [t.strip().lower() for t in search_string.split() if t.strip()]
-
- def test_single_column_search(self):
- condition, params = self._build_text_search(["title"], "python")
- assert "title LIKE ?" in condition
- assert params == ["%python%"]
-
- def test_multi_column_search(self):
- condition, params = self._build_text_search(
- ["title", "content"], "test"
- )
- assert "title LIKE ?" in condition
- assert "content LIKE ?" in condition
- assert "OR" in condition
-
- def test_escape_special_chars(self):
- escaped = self._escape_search_term("100%")
- assert escaped == "100\\%"
-
- def test_tokenize_search(self):
- tokens = self._tokenize_search(" Python Web Development ")
- assert tokens == ["python", "web", "development"]
-
-
-# --- Subquery patterns ---
-
-
-class TestSubqueryBuilder:
- """Tests for subquery building patterns."""
-
- def _build_in_subquery(self, field, subquery):
- """Build IN subquery condition."""
- return f"{field} IN ({subquery})"
-
- def _build_exists_subquery(self, subquery):
- """Build EXISTS subquery condition."""
- return f"EXISTS ({subquery})"
-
- def _wrap_as_subquery(self, query, alias):
- """Wrap query as subquery with alias."""
- return f"({query}) AS {alias}"
-
- def test_in_subquery(self):
- sub = "SELECT user_id FROM active_sessions"
- condition = self._build_in_subquery("id", sub)
- assert condition == "id IN (SELECT user_id FROM active_sessions)"
-
- def test_exists_subquery(self):
- sub = "SELECT 1 FROM orders WHERE orders.user_id = users.id"
- condition = self._build_exists_subquery(sub)
- assert "EXISTS" in condition
-
- def test_wrap_as_subquery(self):
- query = "SELECT id, name FROM users"
- wrapped = self._wrap_as_subquery(query, "u")
- assert wrapped == "(SELECT id, name FROM users) AS u"
-
-
-# --- Insert query patterns ---
-
-
-class TestInsertQuery:
- """Tests for INSERT query building."""
-
- def _build_insert(self, table, columns, values):
- """Build INSERT query."""
- cols = ", ".join(columns)
- placeholders = ", ".join(["?"] * len(values))
- return f"INSERT INTO {table} ({cols}) VALUES ({placeholders})", values
-
- def _build_insert_from_dict(self, table, data):
- """Build INSERT from dictionary."""
- columns = list(data.keys())
- values = list(data.values())
- return self._build_insert(table, columns, values)
-
- def test_simple_insert(self):
- query, params = self._build_insert(
- "users", ["name", "email"], ["John", "[email protected]"]
- )
- assert "INSERT INTO users (name, email) VALUES (?, ?)" == query
- assert params == ["John", "[email protected]"]
-
- def test_insert_from_dict(self):
- data = {"name": "Jane", "status": "active"}
- query, params = self._build_insert_from_dict("users", data)
- assert "name" in query
- assert "status" in query
-
-
-# --- Update query patterns ---
-
-
-class TestUpdateQuery:
- """Tests for UPDATE query building."""
-
- def _build_update(self, table, updates, conditions=None):
- """Build UPDATE query."""
- set_parts = [f"{k} = ?" for k in updates.keys()]
- query = f"UPDATE {table} SET {', '.join(set_parts)}"
- params = list(updates.values())
- if conditions:
- query += f" WHERE {' AND '.join(conditions)}"
- return query, params
-
- def test_update_single_field(self):
- query, params = self._build_update("users", {"status": "active"})
- assert "UPDATE users SET status = ?" == query
- assert params == ["active"]
-
- def test_update_multiple_fields(self):
- query, params = self._build_update(
- "users", {"status": "active", "updated_at": "now"}
- )
- assert "status = ?" in query
- assert "updated_at = ?" in query
-
- def test_update_with_where(self):
- query, params = self._build_update(
- "users", {"status": "inactive"}, ["id = 123"]
- )
- assert "WHERE id = 123" in query
-
-
-# --- Delete query patterns ---
-
-
-class TestDeleteQuery:
- """Tests for DELETE query building."""
-
- def _build_delete(self, table, conditions=None):
- """Build DELETE query."""
- query = f"DELETE FROM {table}"
- if conditions:
- query += f" WHERE {' AND '.join(conditions)}"
- return query
-
- def _build_soft_delete(self, table, conditions):
- """Build soft delete (UPDATE) query."""
- return self._build_update_query(
- table, {"deleted_at": "CURRENT_TIMESTAMP"}, conditions
- )
-
- def _build_update_query(self, table, updates, conditions):
- """Helper for update query."""
- set_parts = [f"{k} = {v}" for k, v in updates.items()]
- query = f"UPDATE {table} SET {', '.join(set_parts)}"
- if conditions:
- query += f" WHERE {' AND '.join(conditions)}"
- return query
-
- def test_delete_all(self):
- query = self._build_delete("temp_data")
- assert query == "DELETE FROM temp_data"
-
- def test_delete_with_condition(self):
- query = self._build_delete("sessions", ["expired = 1"])
- assert "WHERE expired = 1" in query
-
- def test_soft_delete(self):
- query = self._build_soft_delete("users", ["id = 123"])
- assert "UPDATE" in query
- assert "deleted_at" in query
-
-
-# --- Query validation patterns ---
-
-
-class TestQueryValidation:
- """Tests for query validation patterns."""
-
- def _validate_table_name(self, name):
- """Validate table name is safe."""
- import re
-
- return bool(re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name))
-
- def _validate_column_name(self, name):
- """Validate column name is safe."""
- import re
-
- # Allow table.column notation
- return bool(re.match(r"^[a-zA-Z_][a-zA-Z0-9_.]*$", name))
-
- def test_valid_table_name(self):
- assert self._validate_table_name("users") is True
- assert self._validate_table_name("user_profiles") is True
-
- def test_invalid_table_name(self):
- assert self._validate_table_name("users; DROP TABLE") is False
- assert self._validate_table_name("123invalid") is False
-
- def test_valid_column_name(self):
- assert self._validate_column_name("name") is True
- assert self._validate_column_name("users.name") is True
-
- def test_invalid_column_name(self):
- assert self._validate_column_name("name OR 1=1") is False
diff --git a/tests/news/test_rate_limiting_patterns_behavior.py b/tests/news/test_rate_limiting_patterns_behavior.py
deleted file mode 100644
index 006f9df30e..0000000000
--- a/tests/news/test_rate_limiting_patterns_behavior.py
+++ /dev/null
@@ -1,540 +0,0 @@
-"""
-Deep behavioral tests for rate limiting patterns.
-Tests token bucket, sliding window, throttling,
-and burst handling logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-import time
-
-
-# --- Token bucket patterns ---
-
-
-class TestTokenBucket:
- """Tests for token bucket rate limiting."""
-
- def _create_bucket(self, capacity, refill_rate_per_second):
- """Create a token bucket."""
- return {
- "capacity": capacity,
- "tokens": capacity,
- "refill_rate": refill_rate_per_second,
- "last_refill": time.time(),
- }
-
- def _refill(self, bucket):
- """Refill tokens based on elapsed time."""
- now = time.time()
- elapsed = now - bucket["last_refill"]
- tokens_to_add = elapsed * bucket["refill_rate"]
- bucket["tokens"] = min(
- bucket["capacity"], bucket["tokens"] + tokens_to_add
- )
- bucket["last_refill"] = now
- return bucket
-
- def _consume(self, bucket, tokens=1):
- """Try to consume tokens from bucket."""
- self._refill(bucket)
- if bucket["tokens"] >= tokens:
- bucket["tokens"] -= tokens
- return True
- return False
-
- def test_bucket_starts_full(self):
- bucket = self._create_bucket(10, 1)
- assert bucket["tokens"] == 10
-
- def test_consume_reduces_tokens(self):
- bucket = self._create_bucket(10, 1)
- self._consume(bucket, 3)
- assert bucket["tokens"] == 7
-
- def test_consume_fails_when_empty(self):
- bucket = self._create_bucket(2, 1)
- self._consume(bucket, 2)
- result = self._consume(bucket, 1)
- assert result is False
-
- def test_consume_succeeds_with_tokens(self):
- bucket = self._create_bucket(10, 1)
- result = self._consume(bucket, 5)
- assert result is True
-
- def test_capacity_is_max(self):
- bucket = self._create_bucket(10, 1)
- bucket["tokens"] = 5
- bucket["last_refill"] = time.time() - 100 # Long ago
- self._refill(bucket)
- assert bucket["tokens"] == 10
-
-
-# --- Sliding window patterns ---
-
-
-class TestSlidingWindow:
- """Tests for sliding window rate limiting."""
-
- def _create_window(self, window_seconds, max_requests):
- """Create a sliding window."""
- return {
- "window_seconds": window_seconds,
- "max_requests": max_requests,
- "requests": [],
- }
-
- def _record_request(self, window):
- """Record a request in the window."""
- now = datetime.now(timezone.utc)
- cutoff = now - timedelta(seconds=window["window_seconds"])
- # Remove old requests
- window["requests"] = [r for r in window["requests"] if r >= cutoff]
- # Check if allowed
- if len(window["requests"]) >= window["max_requests"]:
- return False
- window["requests"].append(now)
- return True
-
- def _get_remaining(self, window):
- """Get remaining requests in window."""
- now = datetime.now(timezone.utc)
- cutoff = now - timedelta(seconds=window["window_seconds"])
- recent = [r for r in window["requests"] if r >= cutoff]
- return max(0, window["max_requests"] - len(recent))
-
- def test_allows_under_limit(self):
- window = self._create_window(60, 10)
- for _ in range(5):
- assert self._record_request(window) is True
-
- def test_blocks_over_limit(self):
- window = self._create_window(60, 3)
- for _ in range(3):
- self._record_request(window)
- assert self._record_request(window) is False
-
- def test_remaining_decreases(self):
- window = self._create_window(60, 10)
- assert self._get_remaining(window) == 10
- self._record_request(window)
- assert self._get_remaining(window) == 9
-
-
-class TestSlidingWindowCounter:
- """Tests for sliding window counter pattern."""
-
- def _count_in_window(self, timestamps, window_seconds):
- """Count requests in sliding window."""
- now = datetime.now(timezone.utc)
- cutoff = now - timedelta(seconds=window_seconds)
- return sum(1 for ts in timestamps if ts >= cutoff)
-
- def _is_rate_limited(self, timestamps, window_seconds, max_requests):
- """Check if rate limited."""
- return self._count_in_window(timestamps, window_seconds) >= max_requests
-
- def test_counts_recent_only(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(seconds=120)
- timestamps = [old, now, now]
- count = self._count_in_window(timestamps, 60)
- assert count == 2
-
- def test_empty_not_limited(self):
- assert self._is_rate_limited([], 60, 10) is False
-
- def test_at_limit_is_limited(self):
- now = datetime.now(timezone.utc)
- timestamps = [now for _ in range(10)]
- assert self._is_rate_limited(timestamps, 60, 10) is True
-
-
-# --- Fixed window patterns ---
-
-
-class TestFixedWindow:
- """Tests for fixed window rate limiting."""
-
- def _get_window_key(self, window_seconds):
- """Get current window key."""
- now = int(time.time())
- return now // window_seconds
-
- def _check_and_increment(self, counters, window_key, max_requests):
- """Check limit and increment counter."""
- current = counters.get(window_key, 0)
- if current >= max_requests:
- return False, current
- counters[window_key] = current + 1
- return True, current + 1
-
- def test_new_window_starts_at_zero(self):
- counters = {}
- window_key = self._get_window_key(60)
- allowed, count = self._check_and_increment(counters, window_key, 10)
- assert allowed is True
- assert count == 1
-
- def test_increments_counter(self):
- counters = {"key": 5}
- allowed, count = self._check_and_increment(counters, "key", 10)
- assert count == 6
-
- def test_blocks_at_limit(self):
- counters = {"key": 10}
- allowed, count = self._check_and_increment(counters, "key", 10)
- assert allowed is False
-
-
-# --- Throttling patterns ---
-
-
-class TestThrottling:
- """Tests for request throttling patterns."""
-
- def _calculate_delay(self, request_count, base_delay=0.1, max_delay=5.0):
- """Calculate exponential backoff delay."""
- delay = base_delay * (2 ** min(request_count, 10))
- return min(delay, max_delay)
-
- def _should_throttle(self, current_rate, max_rate):
- """Check if should throttle."""
- return current_rate > max_rate
-
- def test_first_request_minimal_delay(self):
- delay = self._calculate_delay(0)
- assert delay == 0.1
-
- def test_delay_increases_exponentially(self):
- delay1 = self._calculate_delay(1)
- delay2 = self._calculate_delay(2)
- delay3 = self._calculate_delay(3)
- assert delay1 < delay2 < delay3
-
- def test_delay_capped_at_max(self):
- delay = self._calculate_delay(100)
- assert delay == 5.0
-
- def test_throttle_when_over_max(self):
- assert self._should_throttle(150, 100) is True
-
- def test_no_throttle_under_max(self):
- assert self._should_throttle(50, 100) is False
-
-
-class TestAdaptiveThrottling:
- """Tests for adaptive throttling patterns."""
-
- def _calculate_adaptive_limit(
- self, success_rate, base_limit, min_limit=10, max_limit=1000
- ):
- """Calculate adaptive rate limit based on success rate."""
- if success_rate >= 0.99:
- return min(int(base_limit * 1.1), max_limit)
- if success_rate < 0.90:
- return max(int(base_limit * 0.8), min_limit)
- return base_limit
-
- def test_high_success_increases_limit(self):
- new_limit = self._calculate_adaptive_limit(0.99, 100)
- assert new_limit == 110
-
- def test_low_success_decreases_limit(self):
- new_limit = self._calculate_adaptive_limit(0.85, 100)
- assert new_limit == 80
-
- def test_normal_success_maintains_limit(self):
- new_limit = self._calculate_adaptive_limit(0.95, 100)
- assert new_limit == 100
-
- def test_respects_max_limit(self):
- new_limit = self._calculate_adaptive_limit(0.99, 950, max_limit=1000)
- assert new_limit == 1000
-
- def test_respects_min_limit(self):
- new_limit = self._calculate_adaptive_limit(0.50, 15, min_limit=10)
- assert new_limit == 12 # 15 * 0.8 = 12
-
-
-# --- Burst handling patterns ---
-
-
-class TestBurstHandling:
- """Tests for burst request handling."""
-
- def _allows_burst(self, bucket, burst_size):
- """Check if burst is allowed."""
- return bucket.get("tokens", 0) >= burst_size
-
- def _calculate_burst_recovery_time(self, needed_tokens, refill_rate):
- """Calculate time to recover tokens for burst."""
- if refill_rate <= 0:
- return float("inf")
- return needed_tokens / refill_rate
-
- def test_burst_allowed_with_tokens(self):
- bucket = {"tokens": 10}
- assert self._allows_burst(bucket, 5) is True
-
- def test_burst_denied_without_tokens(self):
- bucket = {"tokens": 3}
- assert self._allows_burst(bucket, 5) is False
-
- def test_recovery_time_calculation(self):
- recovery = self._calculate_burst_recovery_time(10, 2)
- assert recovery == 5.0 # 10 tokens / 2 per second = 5 seconds
-
-
-# --- Per-user rate limiting patterns ---
-
-
-class TestPerUserRateLimiting:
- """Tests for per-user rate limiting."""
-
- def _get_user_bucket(self, user_buckets, user_id, default_capacity=100):
- """Get or create user's rate limit bucket."""
- if user_id not in user_buckets:
- user_buckets[user_id] = {
- "capacity": default_capacity,
- "tokens": default_capacity,
- "last_refill": time.time(),
- }
- return user_buckets[user_id]
-
- def _check_user_limit(self, user_buckets, user_id, tokens=1):
- """Check if user request is allowed."""
- bucket = self._get_user_bucket(user_buckets, user_id)
- if bucket["tokens"] >= tokens:
- bucket["tokens"] -= tokens
- return True
- return False
-
- def test_new_user_gets_full_bucket(self):
- user_buckets = {}
- bucket = self._get_user_bucket(user_buckets, "user1")
- assert bucket["tokens"] == 100
-
- def test_different_users_separate_buckets(self):
- user_buckets = {}
- self._check_user_limit(user_buckets, "user1", 50)
- bucket1 = self._get_user_bucket(user_buckets, "user1")
- bucket2 = self._get_user_bucket(user_buckets, "user2")
- assert bucket1["tokens"] == 50
- assert bucket2["tokens"] == 100
-
- def test_user_limited_independently(self):
- user_buckets = {}
- # Exhaust user1's tokens
- for _ in range(100):
- self._check_user_limit(user_buckets, "user1")
- # user1 should be limited
- assert self._check_user_limit(user_buckets, "user1") is False
- # user2 should still be allowed
- assert self._check_user_limit(user_buckets, "user2") is True
-
-
-# --- Rate limit headers patterns ---
-
-
-class TestRateLimitHeaders:
- """Tests for rate limit response header patterns."""
-
- def _build_rate_limit_headers(self, remaining, limit, reset_time):
- """Build rate limit headers for response."""
- return {
- "X-RateLimit-Limit": str(limit),
- "X-RateLimit-Remaining": str(max(0, remaining)),
- "X-RateLimit-Reset": str(int(reset_time)),
- }
-
- def _parse_retry_after(self, reset_time):
- """Calculate Retry-After value."""
- now = time.time()
- return max(0, int(reset_time - now))
-
- def test_headers_have_limit(self):
- headers = self._build_rate_limit_headers(50, 100, time.time() + 60)
- assert headers["X-RateLimit-Limit"] == "100"
-
- def test_headers_have_remaining(self):
- headers = self._build_rate_limit_headers(50, 100, time.time() + 60)
- assert headers["X-RateLimit-Remaining"] == "50"
-
- def test_remaining_never_negative(self):
- headers = self._build_rate_limit_headers(-5, 100, time.time() + 60)
- assert headers["X-RateLimit-Remaining"] == "0"
-
- def test_retry_after_calculation(self):
- reset_time = time.time() + 30
- retry_after = self._parse_retry_after(reset_time)
- assert 29 <= retry_after <= 31
-
-
-# --- Endpoint-specific rate limiting patterns ---
-
-
-class TestEndpointRateLimiting:
- """Tests for endpoint-specific rate limits."""
-
- def _get_endpoint_limit(self, endpoint, default_limit=100):
- """Get rate limit for specific endpoint."""
- endpoint_limits = {
- "/api/search": 30,
- "/api/research": 10,
- "/api/news": 60,
- "/api/cards": 100,
- }
- return endpoint_limits.get(endpoint, default_limit)
-
- def _is_sensitive_endpoint(self, endpoint):
- """Check if endpoint is rate-limit sensitive."""
- sensitive = ["/api/research", "/api/llm"]
- return any(s in endpoint for s in sensitive)
-
- def test_search_has_lower_limit(self):
- limit = self._get_endpoint_limit("/api/search")
- assert limit == 30
-
- def test_research_has_lowest_limit(self):
- limit = self._get_endpoint_limit("/api/research")
- assert limit == 10
-
- def test_unknown_endpoint_default(self):
- limit = self._get_endpoint_limit("/api/unknown")
- assert limit == 100
-
- def test_sensitive_endpoint_detected(self):
- assert self._is_sensitive_endpoint("/api/research") is True
- assert self._is_sensitive_endpoint("/api/llm/chat") is True
-
- def test_normal_endpoint_not_sensitive(self):
- assert self._is_sensitive_endpoint("/api/cards") is False
-
-
-# --- Rate limit bypass patterns ---
-
-
-class TestRateLimitBypass:
- """Tests for rate limit bypass conditions."""
-
- def _should_bypass_rate_limit(self, user, endpoint):
- """Check if rate limit should be bypassed."""
- # Admins bypass rate limits
- if user.get("is_admin"):
- return True
- # Whitelisted IPs bypass
- if user.get("ip") in ["127.0.0.1", "::1"]:
- return True
- # Health check endpoints bypass
- if endpoint in ["/health", "/api/health"]:
- return True
- return False
-
- def test_admin_bypasses(self):
- user = {"is_admin": True}
- assert self._should_bypass_rate_limit(user, "/api/search") is True
-
- def test_localhost_bypasses(self):
- user = {"ip": "127.0.0.1"}
- assert self._should_bypass_rate_limit(user, "/api/search") is True
-
- def test_health_endpoint_bypasses(self):
- user = {}
- assert self._should_bypass_rate_limit(user, "/health") is True
-
- def test_normal_user_no_bypass(self):
- user = {"ip": "192.168.1.1"}
- assert self._should_bypass_rate_limit(user, "/api/search") is False
-
-
-# --- Concurrent request patterns ---
-
-
-class TestConcurrentRequestLimiting:
- """Tests for concurrent request limiting."""
-
- def _can_acquire(self, concurrency_tracker, user_id, max_concurrent=5):
- """Try to acquire a concurrency slot."""
- current = concurrency_tracker.get(user_id, 0)
- if current >= max_concurrent:
- return False
- concurrency_tracker[user_id] = current + 1
- return True
-
- def _release(self, concurrency_tracker, user_id):
- """Release a concurrency slot."""
- current = concurrency_tracker.get(user_id, 0)
- if current > 0:
- concurrency_tracker[user_id] = current - 1
- return True
- return False
-
- def test_acquire_succeeds_under_limit(self):
- tracker = {}
- assert self._can_acquire(tracker, "user1") is True
-
- def test_acquire_fails_at_limit(self):
- tracker = {"user1": 5}
- assert self._can_acquire(tracker, "user1") is False
-
- def test_release_decrements(self):
- tracker = {"user1": 3}
- self._release(tracker, "user1")
- assert tracker["user1"] == 2
-
- def test_release_allows_new_acquire(self):
- tracker = {"user1": 5}
- assert self._can_acquire(tracker, "user1") is False
- self._release(tracker, "user1")
- assert self._can_acquire(tracker, "user1") is True
-
-
-# --- Rate limit stats patterns ---
-
-
-class TestRateLimitStats:
- """Tests for rate limit statistics patterns."""
-
- def _build_stats(self, user_buckets):
- """Build rate limit statistics."""
- total_users = len(user_buckets)
- limited_users = sum(
- 1
- for bucket in user_buckets.values()
- if bucket.get("tokens", 0) == 0
- )
- avg_tokens = (
- sum(b.get("tokens", 0) for b in user_buckets.values()) / total_users
- if total_users > 0
- else 0
- )
- return {
- "total_users": total_users,
- "limited_users": limited_users,
- "average_remaining": round(avg_tokens, 2),
- }
-
- def test_counts_total_users(self):
- buckets = {"u1": {"tokens": 50}, "u2": {"tokens": 30}}
- stats = self._build_stats(buckets)
- assert stats["total_users"] == 2
-
- def test_counts_limited_users(self):
- buckets = {
- "u1": {"tokens": 0},
- "u2": {"tokens": 30},
- "u3": {"tokens": 0},
- }
- stats = self._build_stats(buckets)
- assert stats["limited_users"] == 2
-
- def test_calculates_average(self):
- buckets = {"u1": {"tokens": 50}, "u2": {"tokens": 30}}
- stats = self._build_stats(buckets)
- assert stats["average_remaining"] == 40.0
-
- def test_empty_buckets(self):
- stats = self._build_stats({})
- assert stats["total_users"] == 0
- assert stats["average_remaining"] == 0
diff --git a/tests/news/test_rating_storage_deep_behavior.py b/tests/news/test_rating_storage_deep_behavior.py
deleted file mode 100644
index 4e3289755c..0000000000
--- a/tests/news/test_rating_storage_deep_behavior.py
+++ /dev/null
@@ -1,409 +0,0 @@
-"""
-Deep behavioral tests for rating_system/storage.py pure logic.
-Tests rating type mapping, aggregation logic, distribution calculation,
-and list filtering patterns.
-"""
-
-
-# --- Rating distribution calculation ---
-
-
-class TestRatingDistribution:
- """Tests for _get_rating_distribution logic."""
-
- def _get_distribution(self, ratings):
- distribution = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
- for rating in ratings:
- if 1 <= rating <= 5:
- distribution[rating] += 1
- return distribution
-
- def test_empty_ratings(self):
- result = self._get_distribution([])
- assert result == {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
-
- def test_single_rating_5(self):
- result = self._get_distribution([5])
- assert result[5] == 1
- assert result[1] == 0
-
- def test_all_same_rating(self):
- result = self._get_distribution([3, 3, 3, 3])
- assert result[3] == 4
- assert result[1] == 0
- assert result[5] == 0
-
- def test_varied_ratings(self):
- result = self._get_distribution([1, 2, 3, 4, 5])
- assert all(v == 1 for v in result.values())
-
- def test_multiple_of_same(self):
- result = self._get_distribution([5, 5, 4, 4, 4])
- assert result[5] == 2
- assert result[4] == 3
-
- def test_ignores_zero(self):
- result = self._get_distribution([0, 1, 2])
- assert result[1] == 1
- assert result[2] == 1
- # 0 should be ignored
- assert sum(result.values()) == 2
-
- def test_ignores_negative(self):
- result = self._get_distribution([-1, 3, 5])
- assert result[3] == 1
- assert result[5] == 1
-
- def test_ignores_above_5(self):
- result = self._get_distribution([6, 7, 5])
- assert result[5] == 1
- assert sum(result.values()) == 1
-
-
-# --- Relevance vote aggregation ---
-
-
-class TestRelevanceVoteAggregation:
- """Tests for up/down vote aggregation."""
-
- def _aggregate_votes(self, votes):
- up = sum(1 for v in votes if v == "up")
- down = sum(1 for v in votes if v == "down")
- return {"up_votes": up, "down_votes": down, "net_score": up - down}
-
- def test_all_upvotes(self):
- result = self._aggregate_votes(["up", "up", "up"])
- assert result["up_votes"] == 3
- assert result["down_votes"] == 0
- assert result["net_score"] == 3
-
- def test_all_downvotes(self):
- result = self._aggregate_votes(["down", "down"])
- assert result["up_votes"] == 0
- assert result["down_votes"] == 2
- assert result["net_score"] == -2
-
- def test_mixed_votes(self):
- result = self._aggregate_votes(["up", "down", "up", "up"])
- assert result["up_votes"] == 3
- assert result["down_votes"] == 1
- assert result["net_score"] == 2
-
- def test_empty_votes(self):
- result = self._aggregate_votes([])
- assert result["up_votes"] == 0
- assert result["down_votes"] == 0
- assert result["net_score"] == 0
-
- def test_balanced_votes(self):
- result = self._aggregate_votes(["up", "down"])
- assert result["net_score"] == 0
-
-
-# --- Quality rating average ---
-
-
-class TestQualityRatingAverage:
- """Tests for quality rating average calculation."""
-
- def _calc_average(self, values):
- if not values:
- return 0
- return sum(values) / len(values)
-
- def test_empty_returns_zero(self):
- assert self._calc_average([]) == 0
-
- def test_single_value(self):
- assert self._calc_average([5]) == 5
-
- def test_multiple_values(self):
- assert self._calc_average([1, 2, 3, 4, 5]) == 3.0
-
- def test_all_same(self):
- assert self._calc_average([4, 4, 4]) == 4.0
-
- def test_decimal_average(self):
- result = self._calc_average([3, 4])
- assert result == 3.5
-
-
-# --- Rating value parsing ---
-
-
-class TestRatingValueParsing:
- """Tests for parsing rating values from strings."""
-
- def _parse_quality_value(self, value):
- if isinstance(value, str) and value.isdigit():
- return int(value)
- return None
-
- def test_digit_string(self):
- assert self._parse_quality_value("5") == 5
-
- def test_non_digit_string(self):
- assert self._parse_quality_value("up") is None
-
- def test_empty_string(self):
- assert self._parse_quality_value("") is None
-
- def test_numeric_with_spaces(self):
- assert self._parse_quality_value(" 3 ") is None # isdigit fails
-
- def test_integer_already(self):
- # If already int, isinstance(..., str) is False
- result = self._parse_quality_value(5)
- assert result is None # Because not a string
-
-
-# --- Summary structure ---
-
-
-class TestRatingSummaryStructure:
- """Tests for ratings summary structure."""
-
- def _build_summary(self, item_id, item_type, quality, relevance):
- return {
- "item_id": item_id,
- "item_type": item_type,
- "quality": quality,
- "relevance": relevance,
- }
-
- def test_has_item_id(self):
- result = self._build_summary("c1", "card", {}, {})
- assert result["item_id"] == "c1"
-
- def test_has_item_type(self):
- result = self._build_summary("c1", "card", {}, {})
- assert result["item_type"] == "card"
-
- def test_quality_section(self):
- quality = {"count": 5, "average": 4.2, "distribution": {}}
- result = self._build_summary("c1", "card", quality, {})
- assert result["quality"]["count"] == 5
- assert result["quality"]["average"] == 4.2
-
- def test_relevance_section(self):
- relevance = {"up_votes": 10, "down_votes": 2, "net_score": 8}
- result = self._build_summary("c1", "card", {}, relevance)
- assert result["relevance"]["net_score"] == 8
-
-
-# --- List filter patterns ---
-
-
-class TestRatingListFilters:
- """Tests for rating list filtering patterns."""
-
- def _should_filter(self, filters, key):
- return filters and key in filters
-
- def test_filter_user_id(self):
- assert self._should_filter({"user_id": "u1"}, "user_id") is True
-
- def test_filter_item_id(self):
- assert self._should_filter({"item_id": "i1"}, "item_id") is True
-
- def test_filter_item_type(self):
- assert self._should_filter({"item_type": "card"}, "item_type") is True
-
- def test_filter_card_id_backward_compat(self):
- assert self._should_filter({"card_id": "c1"}, "card_id") is True
-
- def test_no_filter(self):
- assert not self._should_filter(None, "user_id")
-
- def test_missing_key(self):
- assert self._should_filter({"user_id": "u1"}, "item_id") is False
-
-
-# --- Rating dict mapping ---
-
-
-class TestRatingDictMapping:
- """Tests for rating to dict mapping."""
-
- def _map_rating(self, rating_dict):
- return {
- "id": rating_dict.get("id"),
- "user_id": rating_dict.get("user_id"),
- "item_id": rating_dict.get("item_id"),
- "item_type": rating_dict.get("item_type"),
- "relevance_vote": rating_dict.get("relevance_vote"),
- "quality_rating": rating_dict.get("quality_rating"),
- "created_at": rating_dict.get("created_at"),
- "updated_at": rating_dict.get("updated_at"),
- }
-
- def test_preserves_id(self):
- result = self._map_rating({"id": 123})
- assert result["id"] == 123
-
- def test_preserves_user_id(self):
- result = self._map_rating({"user_id": "u1"})
- assert result["user_id"] == "u1"
-
- def test_preserves_item_id(self):
- result = self._map_rating({"item_id": "i1"})
- assert result["item_id"] == "i1"
-
- def test_missing_fields_none(self):
- result = self._map_rating({})
- assert result["relevance_vote"] is None
- assert result["quality_rating"] is None
-
-
-# --- Create rating defaults ---
-
-
-class TestCreateRatingDefaults:
- """Tests for create rating default values."""
-
- def _apply_defaults(self, data):
- return {
- "user_id": data["user_id"],
- "item_id": data["item_id"],
- "item_type": data.get("item_type", "card"),
- "relevance_vote": data.get("rating_value"),
- "quality_rating": data.get("quality_rating"),
- }
-
- def test_default_item_type(self):
- result = self._apply_defaults({"user_id": "u1", "item_id": "i1"})
- assert result["item_type"] == "card"
-
- def test_custom_item_type(self):
- result = self._apply_defaults(
- {"user_id": "u1", "item_id": "i1", "item_type": "news"}
- )
- assert result["item_type"] == "news"
-
- def test_rating_value_maps_to_relevance(self):
- result = self._apply_defaults(
- {"user_id": "u1", "item_id": "i1", "rating_value": "up"}
- )
- assert result["relevance_vote"] == "up"
-
-
-# --- Upsert patterns ---
-
-
-class TestUpsertRatingPatterns:
- """Tests for upsert rating logic."""
-
- def _should_update(self, existing):
- return existing is not None
-
- def test_update_when_exists(self):
- assert self._should_update({"id": 1}) is True
-
- def test_create_when_none(self):
- assert self._should_update(None) is False
-
-
-class TestUpsertDataBuilding:
- """Tests for building upsert create data."""
-
- def _build_create_data(
- self, user_id, item_id, item_type, rating_type, rating_value
- ):
- return {
- "user_id": user_id,
- "item_id": item_id,
- "item_type": item_type,
- "rating_type": rating_type,
- "rating_value": rating_value,
- }
-
- def test_all_fields_set(self):
- result = self._build_create_data("u1", "i1", "card", "quality", "5")
- assert result["user_id"] == "u1"
- assert result["item_id"] == "i1"
- assert result["item_type"] == "card"
- assert result["rating_type"] == "quality"
- assert result["rating_value"] == "5"
-
-
-# --- Item type query logic ---
-
-
-class TestItemTypeQueryLogic:
- """Tests for item type based query selection."""
-
- def _get_filter_field(self, item_type):
- if item_type == "card":
- return "card_id"
- return "news_item_id"
-
- def test_card_type(self):
- assert self._get_filter_field("card") == "card_id"
-
- def test_news_type(self):
- assert self._get_filter_field("news") == "news_item_id"
-
- def test_other_type(self):
- assert self._get_filter_field("other") == "news_item_id"
-
-
-# --- Get user ratings logic ---
-
-
-class TestGetUserRatingsLogic:
- """Tests for get_user_ratings filter building."""
-
- def _build_filters(self, user_id, rating_type=None):
- filters = {"user_id": user_id}
- if rating_type:
- filters["rating_type"] = rating_type
- return filters
-
- def test_user_only(self):
- result = self._build_filters("u1")
- assert result == {"user_id": "u1"}
-
- def test_user_and_type(self):
- result = self._build_filters("u1", "quality")
- assert result == {"user_id": "u1", "rating_type": "quality"}
-
- def test_none_type_ignored(self):
- result = self._build_filters("u1", None)
- assert "rating_type" not in result
-
-
-# --- Rating value update ---
-
-
-class TestRatingValueUpdate:
- """Tests for rating value update patterns."""
-
- def _update_fields(self, data):
- updates = {}
- if "rating_value" in data:
- updates["rating_value"] = data["rating_value"]
- if "comment" in data:
- updates["comment"] = data["comment"]
- return updates
-
- def test_update_rating_value(self):
- result = self._update_fields({"rating_value": "down"})
- assert result["rating_value"] == "down"
-
- def test_update_comment(self):
- result = self._update_fields({"comment": "Great!"})
- assert result["comment"] == "Great!"
-
- def test_update_both(self):
- result = self._update_fields({"rating_value": "up", "comment": "Nice"})
- assert result["rating_value"] == "up"
- assert result["comment"] == "Nice"
-
- def test_ignore_other_fields(self):
- result = self._update_fields({"user_id": "u1", "rating_value": "up"})
- assert "user_id" not in result
- assert result["rating_value"] == "up"
-
- def test_empty_data(self):
- result = self._update_fields({})
- assert result == {}
diff --git a/tests/news/test_rating_storage_logic_behavior.py b/tests/news/test_rating_storage_logic_behavior.py
deleted file mode 100644
index 242eff33b4..0000000000
--- a/tests/news/test_rating_storage_logic_behavior.py
+++ /dev/null
@@ -1,288 +0,0 @@
-"""
-Deep behavioral tests for rating storage logic patterns.
-Tests rating distribution, summary aggregation, vote counting,
-quality average calculation, and upsert patterns.
-"""
-
-
-# --- Rating distribution ---
-
-
-class TestRatingDistributionLogic:
- """Tests for _get_rating_distribution logic pattern."""
-
- def _get_distribution(self, ratings):
- distribution = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
- for rating in ratings:
- if 1 <= rating <= 5:
- distribution[rating] += 1
- return distribution
-
- def test_empty_input(self):
- assert self._get_distribution([]) == {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
-
- def test_single_one(self):
- result = self._get_distribution([1])
- assert result[1] == 1
-
- def test_single_five(self):
- result = self._get_distribution([5])
- assert result[5] == 1
-
- def test_all_same(self):
- result = self._get_distribution([3, 3, 3])
- assert result[3] == 3
- assert result[1] == 0
-
- def test_all_values(self):
- result = self._get_distribution([1, 2, 3, 4, 5])
- for k in range(1, 6):
- assert result[k] == 1
-
- def test_out_of_range_zero(self):
- result = self._get_distribution([0])
- assert result == {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
-
- def test_out_of_range_six(self):
- result = self._get_distribution([6])
- assert result == {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
-
- def test_negative(self):
- result = self._get_distribution([-1])
- assert result == {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
-
- def test_mixed_valid_invalid(self):
- result = self._get_distribution([0, 1, 6, 2, -1, 3, 100])
- assert result == {1: 1, 2: 1, 3: 1, 4: 0, 5: 0}
-
- def test_large_count(self):
- result = self._get_distribution([4] * 1000)
- assert result[4] == 1000
-
-
-# --- Quality average calculation ---
-
-
-class TestQualityAverageCalculation:
- """Tests for quality rating average calculation."""
-
- def test_simple_average(self):
- values = [3, 4, 5]
- avg = sum(values) / len(values)
- assert avg == 4.0
-
- def test_single_value(self):
- values = [5]
- avg = sum(values) / len(values)
- assert avg == 5.0
-
- def test_all_ones(self):
- values = [1, 1, 1]
- avg = sum(values) / len(values)
- assert avg == 1.0
-
- def test_empty_returns_zero(self):
- values = []
- avg = sum(values) / len(values) if values else 0
- assert avg == 0
-
- def test_fractional_average(self):
- values = [1, 2]
- avg = sum(values) / len(values)
- assert avg == 1.5
-
- def test_all_fives(self):
- values = [5, 5, 5, 5, 5]
- avg = sum(values) / len(values)
- assert avg == 5.0
-
- def test_realistic_distribution(self):
- values = [3, 4, 5, 4, 3, 2, 4, 5, 3, 4]
- avg = sum(values) / len(values)
- assert abs(avg - 3.7) < 0.01
-
-
-# --- Relevance vote counting ---
-
-
-class TestRelevanceVoteCounting:
- """Tests for relevance vote counting patterns."""
-
- def test_count_up_votes(self):
- values = ["up", "down", "up", "up"]
- up = sum(1 for v in values if v == "up")
- assert up == 3
-
- def test_count_down_votes(self):
- values = ["up", "down", "up", "down"]
- down = sum(1 for v in values if v == "down")
- assert down == 2
-
- def test_net_score_positive(self):
- up, down = 10, 3
- assert up - down == 7
-
- def test_net_score_negative(self):
- up, down = 2, 8
- assert up - down == -6
-
- def test_net_score_zero(self):
- up, down = 5, 5
- assert up - down == 0
-
- def test_no_votes(self):
- values = []
- up = sum(1 for v in values if v == "up")
- down = sum(1 for v in values if v == "down")
- assert up == 0
- assert down == 0
-
-
-# --- isdigit filter ---
-
-
-class TestIsdigitFilter:
- """Tests for the isdigit filter pattern used in rating values."""
-
- def test_valid_digits(self):
- raw = ["1", "2", "3", "4", "5"]
- filtered = [int(v) for v in raw if v.isdigit()]
- assert filtered == [1, 2, 3, 4, 5]
-
- def test_non_digit_filtered(self):
- raw = ["3", "four", "5"]
- filtered = [int(v) for v in raw if v.isdigit()]
- assert filtered == [3, 5]
-
- def test_empty_string_filtered(self):
- raw = ["3", "", "5"]
- filtered = [int(v) for v in raw if v.isdigit()]
- assert filtered == [3, 5]
-
- def test_float_string_filtered(self):
- raw = ["3.5", "4"]
- filtered = [int(v) for v in raw if v.isdigit()]
- # "3.5" is not a digit string
- assert filtered == [4]
-
- def test_negative_filtered(self):
- raw = ["-1", "3"]
- filtered = [int(v) for v in raw if v.isdigit()]
- # "-1" is not a digit string
- assert filtered == [3]
-
- def test_all_invalid(self):
- raw = ["abc", "", "x.y"]
- filtered = [int(v) for v in raw if v.isdigit()]
- assert filtered == []
-
-
-# --- Rating summary structure ---
-
-
-class TestRatingSummaryStructure:
- """Tests for the rating summary response structure."""
-
- def test_has_item_id(self):
- summary = {
- "item_id": "card-123",
- "item_type": "card",
- "quality": {"count": 0, "average": 0, "distribution": {}},
- "relevance": {"up_votes": 0, "down_votes": 0, "net_score": 0},
- }
- assert summary["item_id"] == "card-123"
-
- def test_has_quality_section(self):
- summary = {
- "item_id": "card-123",
- "item_type": "card",
- "quality": {
- "count": 5,
- "average": 3.8,
- "distribution": {1: 0, 2: 0, 3: 1, 4: 3, 5: 1},
- },
- "relevance": {"up_votes": 10, "down_votes": 2, "net_score": 8},
- }
- assert summary["quality"]["count"] == 5
- assert summary["quality"]["average"] == 3.8
-
- def test_has_relevance_section(self):
- summary = {
- "item_id": "card-123",
- "item_type": "card",
- "quality": {"count": 0, "average": 0, "distribution": {}},
- "relevance": {"up_votes": 10, "down_votes": 2, "net_score": 8},
- }
- assert summary["relevance"]["up_votes"] == 10
- assert summary["relevance"]["down_votes"] == 2
- assert summary["relevance"]["net_score"] == 8
-
- def test_net_score_matches_calculation(self):
- up = 15
- down = 7
- summary = {
- "relevance": {
- "up_votes": up,
- "down_votes": down,
- "net_score": up - down,
- },
- }
- assert summary["relevance"]["net_score"] == 8
-
-
-# --- Upsert pattern ---
-
-
-class TestUpsertPattern:
- """Tests for the create-or-update (upsert) pattern."""
-
- def test_create_when_no_existing(self):
- existing = None
- if existing:
- action = "update"
- else:
- action = "create"
- assert action == "create"
-
- def test_update_when_existing(self):
- existing = {"id": 1, "rating_value": "up"}
- if existing:
- action = "update"
- else:
- action = "create"
- assert action == "update"
-
- def test_existing_id_used_for_update(self):
- existing = {"id": 42, "rating_value": "up"}
- if existing:
- update_id = str(existing["id"])
- else:
- update_id = None
- assert update_id == "42"
-
-
-# --- Item type patterns ---
-
-
-class TestItemTypePatterns:
- """Tests for item type handling in rating storage."""
-
- def test_default_item_type_card(self):
- item_type = "card"
- assert item_type == "card"
-
- def test_news_item_type(self):
- item_type = "news_item"
- is_card = item_type == "card"
- assert not is_card
-
- def test_card_id_backward_compat(self):
- """card_id filter maps to item_id for backward compatibility."""
- filters = {"card_id": "card-123"}
- item_id = filters.get("card_id")
- assert item_id == "card-123"
-
- def test_item_id_preferred(self):
- filters = {"item_id": "item-123", "card_id": "card-123"}
- item_id = filters.get("item_id")
- assert item_id == "item-123"
diff --git a/tests/news/test_relevance_service_logic_behavior.py b/tests/news/test_relevance_service_logic_behavior.py
deleted file mode 100644
index 008f4eb188..0000000000
--- a/tests/news/test_relevance_service_logic_behavior.py
+++ /dev/null
@@ -1,639 +0,0 @@
-"""
-Deep behavioral tests for relevance_service.py.
-Tests calculate_relevance scoring, calculate_trending_score,
-filter_trending, personalize_feed, and edge cases.
-"""
-
-from unittest.mock import Mock
-
-
-def _make_card(**kwargs):
- """Create a mock card with configurable attributes."""
- card = Mock()
- card.impact_score = kwargs.get("impact_score", 5)
- card.category = kwargs.get("category", "General")
- card.topics = kwargs.get("topics", [])
- card.interaction = kwargs.get("interaction", {})
- card.relevance_score = 0
- card.trending_score = 0
- return card
-
-
-# --- calculate_relevance ---
-
-
-class TestCalculateRelevanceNoPrefs:
- """Tests for calculate_relevance without user preferences."""
-
- def _calc(self, card, prefs):
- if not prefs:
- return getattr(card, "impact_score", 5) / 10.0
- score = 0.5
- if hasattr(card, "category"):
- if card.category in prefs.get("liked_categories", []):
- score += 0.2
- elif card.category in prefs.get("disliked_categories", []):
- score -= 0.2
- if hasattr(card, "impact_score"):
- threshold = prefs.get("impact_threshold", 5)
- if card.impact_score >= threshold:
- score += 0.1
- else:
- score -= 0.1
- if hasattr(card, "topics"):
- liked_topics = prefs.get("liked_topics", [])
- for topic in card.topics:
- if any(liked in topic.lower() for liked in liked_topics):
- score += 0.1
- break
- return max(0.0, min(1.0, score))
-
- def test_no_prefs_uses_impact(self):
- card = _make_card(impact_score=8)
- assert self._calc(card, None) == 0.8
-
- def test_no_prefs_low_impact(self):
- card = _make_card(impact_score=2)
- assert self._calc(card, None) == 0.2
-
- def test_no_prefs_zero_impact(self):
- card = _make_card(impact_score=0)
- assert self._calc(card, None) == 0.0
-
- def test_no_prefs_max_impact(self):
- card = _make_card(impact_score=10)
- assert self._calc(card, None) == 1.0
-
- def test_empty_prefs_uses_impact(self):
- card = _make_card(impact_score=5)
- assert self._calc(card, None) == 0.5
-
-
-class TestCalculateRelevanceLikedCategory:
- """Tests for liked/disliked category effects."""
-
- def _calc(self, card, prefs):
- if not prefs:
- return getattr(card, "impact_score", 5) / 10.0
- score = 0.5
- if hasattr(card, "category"):
- if card.category in prefs.get("liked_categories", []):
- score += 0.2
- elif card.category in prefs.get("disliked_categories", []):
- score -= 0.2
- if hasattr(card, "impact_score"):
- threshold = prefs.get("impact_threshold", 5)
- if card.impact_score >= threshold:
- score += 0.1
- else:
- score -= 0.1
- if hasattr(card, "topics"):
- liked_topics = prefs.get("liked_topics", [])
- for topic in card.topics:
- if any(liked in topic.lower() for liked in liked_topics):
- score += 0.1
- break
- return max(0.0, min(1.0, score))
-
- def test_liked_category_boosts(self):
- card = _make_card(category="Tech", impact_score=5)
- prefs = {"liked_categories": ["Tech"]}
- score = self._calc(card, prefs)
- assert score > 0.5
-
- def test_disliked_category_penalizes(self):
- card = _make_card(category="Sports", impact_score=5)
- prefs = {"disliked_categories": ["Sports"]}
- score = self._calc(card, prefs)
- assert score < 0.5
-
- def test_neutral_category(self):
- card = _make_card(category="Science", impact_score=5)
- prefs = {"liked_categories": ["Tech"]}
- score = self._calc(card, prefs)
- # base 0.5 + 0.1 (impact >= threshold 5) = 0.6
- assert score == 0.6
-
- def test_liked_and_high_impact(self):
- card = _make_card(category="Tech", impact_score=9)
- prefs = {"liked_categories": ["Tech"]}
- score = self._calc(card, prefs)
- # 0.5 + 0.2 (liked) + 0.1 (high impact) = 0.8
- assert abs(score - 0.8) < 0.01
-
- def test_disliked_and_low_impact(self):
- card = _make_card(category="Sports", impact_score=3)
- prefs = {"disliked_categories": ["Sports"], "impact_threshold": 5}
- score = self._calc(card, prefs)
- # 0.5 - 0.2 (disliked) - 0.1 (low impact) = 0.2
- assert abs(score - 0.2) < 0.01
-
-
-class TestCalculateRelevanceImpactThreshold:
- """Tests for impact threshold effects."""
-
- def _calc(self, card, prefs):
- if not prefs:
- return getattr(card, "impact_score", 5) / 10.0
- score = 0.5
- if hasattr(card, "category"):
- if card.category in prefs.get("liked_categories", []):
- score += 0.2
- elif card.category in prefs.get("disliked_categories", []):
- score -= 0.2
- if hasattr(card, "impact_score"):
- threshold = prefs.get("impact_threshold", 5)
- if card.impact_score >= threshold:
- score += 0.1
- else:
- score -= 0.1
- if hasattr(card, "topics"):
- liked_topics = prefs.get("liked_topics", [])
- for topic in card.topics:
- if any(liked in topic.lower() for liked in liked_topics):
- score += 0.1
- break
- return max(0.0, min(1.0, score))
-
- def test_above_threshold(self):
- card = _make_card(impact_score=8)
- prefs = {"impact_threshold": 7}
- score = self._calc(card, prefs)
- assert score == 0.6 # 0.5 + 0.1
-
- def test_below_threshold(self):
- card = _make_card(impact_score=3)
- prefs = {"impact_threshold": 7}
- score = self._calc(card, prefs)
- assert score == 0.4 # 0.5 - 0.1
-
- def test_exactly_at_threshold(self):
- card = _make_card(impact_score=5)
- prefs = {"impact_threshold": 5}
- score = self._calc(card, prefs)
- assert score == 0.6 # >= threshold
-
- def test_default_threshold_5(self):
- card = _make_card(impact_score=5)
- prefs = {}
- score = self._calc(card, prefs)
- # Empty dict {} is falsy in Python, so `not prefs` is True
- # This means it takes the "no prefs" path: impact_score / 10
- assert score == 0.5 # 5 / 10 = 0.5
-
-
-class TestCalculateRelevanceTopicMatching:
- """Tests for topic matching effects."""
-
- def _calc(self, card, prefs):
- if not prefs:
- return getattr(card, "impact_score", 5) / 10.0
- score = 0.5
- if hasattr(card, "category"):
- if card.category in prefs.get("liked_categories", []):
- score += 0.2
- elif card.category in prefs.get("disliked_categories", []):
- score -= 0.2
- if hasattr(card, "impact_score"):
- threshold = prefs.get("impact_threshold", 5)
- if card.impact_score >= threshold:
- score += 0.1
- else:
- score -= 0.1
- if hasattr(card, "topics"):
- liked_topics = prefs.get("liked_topics", [])
- for topic in card.topics:
- if any(liked in topic.lower() for liked in liked_topics):
- score += 0.1
- break
- return max(0.0, min(1.0, score))
-
- def test_matching_topic_boosts(self):
- card = _make_card(topics=["artificial intelligence"], impact_score=5)
- prefs = {"liked_topics": ["artificial"]}
- score = self._calc(card, prefs)
- # 0.5 + 0.1 (impact) + 0.1 (topic) = 0.7
- assert score == 0.7
-
- def test_no_matching_topic(self):
- card = _make_card(topics=["climate change"], impact_score=5)
- prefs = {"liked_topics": ["sports"]}
- score = self._calc(card, prefs)
- assert score == 0.6 # only impact boost
-
- def test_empty_topics(self):
- card = _make_card(topics=[], impact_score=5)
- prefs = {"liked_topics": ["ai"]}
- score = self._calc(card, prefs)
- assert score == 0.6
-
- def test_topic_matching_is_case_insensitive(self):
- card = _make_card(topics=["AI Research"], impact_score=5)
- prefs = {"liked_topics": ["ai"]}
- score = self._calc(card, prefs)
- assert score == 0.7
-
- def test_only_one_boost_per_card(self):
- card = _make_card(
- topics=["AI News", "AI Research", "AI Updates"], impact_score=5
- )
- prefs = {"liked_topics": ["ai"]}
- score = self._calc(card, prefs)
- assert score == 0.7 # break after first match
-
-
-class TestCalculateRelevanceClamping:
- """Tests for score clamping to [0, 1]."""
-
- def _calc(self, card, prefs):
- if not prefs:
- return getattr(card, "impact_score", 5) / 10.0
- score = 0.5
- if hasattr(card, "category"):
- if card.category in prefs.get("liked_categories", []):
- score += 0.2
- elif card.category in prefs.get("disliked_categories", []):
- score -= 0.2
- if hasattr(card, "impact_score"):
- threshold = prefs.get("impact_threshold", 5)
- if card.impact_score >= threshold:
- score += 0.1
- else:
- score -= 0.1
- if hasattr(card, "topics"):
- liked_topics = prefs.get("liked_topics", [])
- for topic in card.topics:
- if any(liked in topic.lower() for liked in liked_topics):
- score += 0.1
- break
- return max(0.0, min(1.0, score))
-
- def test_max_possible_score(self):
- card = _make_card(category="Tech", impact_score=10, topics=["AI"])
- prefs = {
- "liked_categories": ["Tech"],
- "liked_topics": ["ai"],
- }
- score = self._calc(card, prefs)
- assert score <= 1.0
-
- def test_min_possible_score(self):
- card = _make_card(category="Sports", impact_score=1, topics=[])
- prefs = {
- "disliked_categories": ["Sports"],
- "impact_threshold": 10,
- }
- score = self._calc(card, prefs)
- assert score >= 0.0
-
-
-# --- calculate_trending_score ---
-
-
-class TestCalculateTrendingScore:
- """Tests for trending score calculation."""
-
- def _trending(self, card):
- if not hasattr(card, "impact_score"):
- return 0.0
- engagement = (
- card.interaction.get("views", 0)
- + card.interaction.get("votes_up", 0) * 2
- - card.interaction.get("votes_down", 0)
- )
- return card.impact_score + (engagement / 10)
-
- def test_no_engagement(self):
- card = _make_card(impact_score=7, interaction={})
- assert self._trending(card) == 7.0
-
- def test_views_contribute(self):
- card = _make_card(impact_score=5, interaction={"views": 100})
- score = self._trending(card)
- assert score == 15.0 # 5 + 100/10
-
- def test_votes_up_weighted_double(self):
- card = _make_card(impact_score=5, interaction={"votes_up": 10})
- score = self._trending(card)
- assert score == 7.0 # 5 + (10*2)/10
-
- def test_votes_down_subtract(self):
- card = _make_card(impact_score=5, interaction={"votes_down": 10})
- score = self._trending(card)
- assert score == 4.0 # 5 + (-10)/10
-
- def test_combined_engagement(self):
- card = _make_card(
- impact_score=5,
- interaction={"views": 50, "votes_up": 10, "votes_down": 5},
- )
- score = self._trending(card)
- # 5 + (50 + 20 - 5) / 10 = 5 + 6.5 = 11.5
- assert score == 11.5
-
- def test_no_impact_score_attr(self):
- card = Mock(spec=[])
- assert self._trending(card) == 0.0
-
- def test_zero_impact(self):
- card = _make_card(impact_score=0, interaction={"views": 10})
- score = self._trending(card)
- assert score == 1.0
-
-
-# --- filter_trending ---
-
-
-class TestFilterTrending:
- """Tests for trending card filtering."""
-
- def _filter(self, cards, min_impact=7, limit=10):
- trending = []
- for card in cards:
- if (
- hasattr(card, "impact_score")
- and card.impact_score >= min_impact
- ):
- engagement = (
- card.interaction.get("views", 0)
- + card.interaction.get("votes_up", 0) * 2
- - card.interaction.get("votes_down", 0)
- )
- card.trending_score = card.impact_score + (engagement / 10)
- trending.append(card)
- trending.sort(key=lambda c: c.trending_score, reverse=True)
- return trending[:limit]
-
- def test_empty_cards(self):
- assert self._filter([]) == []
-
- def test_filters_below_min_impact(self):
- cards = [_make_card(impact_score=5), _make_card(impact_score=8)]
- result = self._filter(cards, min_impact=7)
- assert len(result) == 1
- assert result[0].impact_score == 8
-
- def test_sorts_by_trending_score(self):
- c1 = _make_card(impact_score=8, interaction={"views": 100})
- c2 = _make_card(impact_score=9, interaction={"views": 10})
- result = self._filter([c1, c2])
- assert result[0] is c1 # 8 + 10 = 18 > 9 + 1 = 10
-
- def test_respects_limit(self):
- cards = [_make_card(impact_score=8) for _ in range(20)]
- result = self._filter(cards, limit=5)
- assert len(result) == 5
-
- def test_min_impact_boundary(self):
- cards = [
- _make_card(impact_score=6),
- _make_card(impact_score=7),
- _make_card(impact_score=8),
- ]
- result = self._filter(cards, min_impact=7)
- assert len(result) == 2
-
- def test_custom_min_impact(self):
- cards = [_make_card(impact_score=3)]
- result = self._filter(cards, min_impact=3)
- assert len(result) == 1
-
-
-# --- personalize_feed ---
-
-
-class TestPersonalizeFeed:
- """Tests for feed personalization."""
-
- def _personalize(self, cards, prefs, include_seen=True):
- personalized = []
- for card in cards:
- if not prefs:
- card.relevance_score = getattr(card, "impact_score", 5) / 10.0
- else:
- card.relevance_score = 0.5
- if not include_seen and card.interaction.get("viewed"):
- continue
- personalized.append(card)
- personalized.sort(key=lambda c: c.relevance_score, reverse=True)
- return personalized
-
- def test_empty_cards(self):
- assert self._personalize([], None) == []
-
- def test_sorts_by_relevance(self):
- c1 = _make_card(impact_score=3)
- c2 = _make_card(impact_score=9)
- result = self._personalize([c1, c2], None)
- assert result[0] is c2
-
- def test_filters_seen_when_requested(self):
- c1 = _make_card(interaction={"viewed": True})
- c2 = _make_card(interaction={})
- result = self._personalize([c1, c2], None, include_seen=False)
- assert len(result) == 1
- assert result[0] is c2
-
- def test_includes_seen_by_default(self):
- c1 = _make_card(interaction={"viewed": True})
- c2 = _make_card(interaction={})
- result = self._personalize([c1, c2], None, include_seen=True)
- assert len(result) == 2
-
- def test_all_seen_excluded(self):
- cards = [_make_card(interaction={"viewed": True}) for _ in range(3)]
- result = self._personalize(cards, None, include_seen=False)
- assert result == []
-
-
-# --- InteractionType enum patterns ---
-
-
-class TestInteractionTypePatterns:
- """Tests for InteractionType enum-like patterns."""
-
- def test_view_type(self):
- assert "view" == "view"
-
- def test_vote_up_type(self):
- assert "vote_up" == "vote_up"
-
- def test_vote_down_type(self):
- assert "vote_down" == "vote_down"
-
- def test_research_type(self):
- assert "research" == "research"
-
- def test_share_type(self):
- assert "share" == "share"
-
-
-# --- Interaction recording patterns ---
-
-
-class TestInteractionRecordingPatterns:
- """Tests for interaction recording logic from StorageManager."""
-
- def test_view_increments_views(self):
- interaction = {"views": 5}
- interaction["viewed"] = True
- interaction["views"] = interaction.get("views", 0) + 1
- assert interaction["views"] == 6
- assert interaction["viewed"] is True
-
- def test_view_first_time(self):
- interaction = {}
- interaction["viewed"] = True
- interaction["views"] = interaction.get("views", 0) + 1
- assert interaction["views"] == 1
-
- def test_vote_up_increments(self):
- interaction = {"votes_up": 3}
- interaction["voted"] = "up"
- interaction["votes_up"] = interaction.get("votes_up", 0) + 1
- assert interaction["votes_up"] == 4
- assert interaction["voted"] == "up"
-
- def test_vote_down_increments(self):
- interaction = {"votes_down": 2}
- interaction["voted"] = "down"
- interaction["votes_down"] = interaction.get("votes_down", 0) + 1
- assert interaction["votes_down"] == 3
-
- def test_research_increments(self):
- interaction = {}
- interaction["researched"] = True
- interaction["research_count"] = interaction.get("research_count", 0) + 1
- assert interaction["research_count"] == 1
- assert interaction["researched"] is True
-
- def test_metadata_attached(self):
- interaction = {}
- metadata = {"source": "web"}
- interaction_type = "view"
- interaction[f"{interaction_type}_metadata"] = metadata
- assert interaction["view_metadata"] == {"source": "web"}
-
-
-# --- Card interaction vote mapping ---
-
-
-class TestCardInteractionVoteMapping:
- """Tests for converting ratings to interaction format."""
-
- def _convert_ratings(self, ratings):
- interactions = []
- for rating in ratings:
- interaction = {
- "user_id": rating.get("user_id"),
- "interaction_type": "vote",
- "interaction_data": {
- "vote": "up" if rating.get("value", 0) > 0 else "down"
- },
- "timestamp": rating.get("created_at"),
- }
- interactions.append(interaction)
- return interactions
-
- def test_positive_rating_maps_to_up(self):
- ratings = [{"user_id": "u1", "value": 1}]
- result = self._convert_ratings(ratings)
- assert result[0]["interaction_data"]["vote"] == "up"
-
- def test_negative_rating_maps_to_down(self):
- ratings = [{"user_id": "u1", "value": -1}]
- result = self._convert_ratings(ratings)
- assert result[0]["interaction_data"]["vote"] == "down"
-
- def test_zero_rating_maps_to_down(self):
- ratings = [{"user_id": "u1", "value": 0}]
- result = self._convert_ratings(ratings)
- assert result[0]["interaction_data"]["vote"] == "down"
-
- def test_preserves_user_id(self):
- ratings = [{"user_id": "user42", "value": 1}]
- result = self._convert_ratings(ratings)
- assert result[0]["user_id"] == "user42"
-
- def test_preserves_timestamp(self):
- ratings = [{"user_id": "u1", "value": 1, "created_at": "2025-01-01"}]
- result = self._convert_ratings(ratings)
- assert result[0]["timestamp"] == "2025-01-01"
-
- def test_empty_ratings(self):
- assert self._convert_ratings([]) == []
-
- def test_multiple_ratings(self):
- ratings = [
- {"user_id": "u1", "value": 1},
- {"user_id": "u2", "value": -1},
- ]
- result = self._convert_ratings(ratings)
- assert len(result) == 2
-
-
-# --- User stats aggregation ---
-
-
-class TestUserStatsAggregation:
- """Tests for user stats calculation patterns."""
-
- def _calc_stats(self, ratings, cards):
- votes_up = sum(1 for r in ratings if r.get("value", 0) > 0)
- votes_down = sum(1 for r in ratings if r.get("value", 0) < 0)
- total_views = sum(
- c.get("interaction", {}).get("views", 0) for c in cards
- )
- return {
- "votes_up": votes_up,
- "votes_down": votes_down,
- "total_views": total_views,
- "cards_created": len(cards),
- "member_since": cards[0]["created_at"] if cards else None,
- }
-
- def test_votes_counted(self):
- ratings = [{"value": 1}, {"value": -1}, {"value": 1}]
- stats = self._calc_stats(ratings, [])
- assert stats["votes_up"] == 2
- assert stats["votes_down"] == 1
-
- def test_views_summed(self):
- cards = [
- {"interaction": {"views": 5}, "created_at": "2025-01-01"},
- {"interaction": {"views": 10}, "created_at": "2025-01-02"},
- ]
- stats = self._calc_stats([], cards)
- assert stats["total_views"] == 15
-
- def test_cards_created_count(self):
- cards = [{"created_at": "2025-01-01"} for _ in range(5)]
- stats = self._calc_stats([], cards)
- assert stats["cards_created"] == 5
-
- def test_member_since_first_card(self):
- cards = [{"created_at": "2025-01-01"}, {"created_at": "2025-02-01"}]
- stats = self._calc_stats([], cards)
- assert stats["member_since"] == "2025-01-01"
-
- def test_member_since_none_when_no_cards(self):
- stats = self._calc_stats([], [])
- assert stats["member_since"] is None
-
- def test_empty_everything(self):
- stats = self._calc_stats([], [])
- assert stats["votes_up"] == 0
- assert stats["votes_down"] == 0
- assert stats["total_views"] == 0
- assert stats["cards_created"] == 0
-
- def test_zero_value_ratings_not_counted(self):
- ratings = [{"value": 0}, {"value": 0}]
- stats = self._calc_stats(ratings, [])
- assert stats["votes_up"] == 0
- assert stats["votes_down"] == 0
-
- def test_missing_interaction_key(self):
- cards = [{"created_at": "2025-01-01"}]
- stats = self._calc_stats([], cards)
- assert stats["total_views"] == 0
diff --git a/tests/news/test_scheduler_document_behavior.py b/tests/news/test_scheduler_document_behavior.py
deleted file mode 100644
index 8e0f7ddf4a..0000000000
--- a/tests/news/test_scheduler_document_behavior.py
+++ /dev/null
@@ -1,574 +0,0 @@
-"""
-Deep behavioral tests for scheduler document processing patterns.
-Tests DocumentSchedulerSettings, settings caching, document processing
-configuration, and RAG indexing patterns.
-"""
-
-from dataclasses import dataclass, FrozenInstanceError
-from datetime import datetime, timezone, timedelta
-import threading
-
-import pytest
-
-
-# --- DocumentSchedulerSettings dataclass ---
-
-
-@dataclass(frozen=True)
-class DocumentSchedulerSettings:
- """Test version of DocumentSchedulerSettings."""
-
- enabled: bool = True
- interval_seconds: int = 1800
- download_pdfs: bool = False
- extract_text: bool = True
- generate_rag: bool = False
- last_run: str = ""
-
- @classmethod
- def defaults(cls):
- return cls()
-
-
-class TestDocumentSchedulerSettingsDefaults:
- """Tests for DocumentSchedulerSettings default values."""
-
- def test_enabled_default_true(self):
- settings = DocumentSchedulerSettings()
- assert settings.enabled is True
-
- def test_interval_default_1800(self):
- settings = DocumentSchedulerSettings()
- assert settings.interval_seconds == 1800
-
- def test_download_pdfs_default_false(self):
- settings = DocumentSchedulerSettings()
- assert settings.download_pdfs is False
-
- def test_extract_text_default_true(self):
- settings = DocumentSchedulerSettings()
- assert settings.extract_text is True
-
- def test_generate_rag_default_false(self):
- settings = DocumentSchedulerSettings()
- assert settings.generate_rag is False
-
- def test_last_run_default_empty(self):
- settings = DocumentSchedulerSettings()
- assert settings.last_run == ""
-
- def test_defaults_classmethod(self):
- settings = DocumentSchedulerSettings.defaults()
- assert settings.enabled is True
- assert settings.interval_seconds == 1800
-
-
-class TestDocumentSchedulerSettingsImmutability:
- """Tests for frozen dataclass immutability."""
-
- def test_cannot_modify_enabled(self):
- """``FrozenInstanceError`` subclasses ``AttributeError``; the
- ``pytest.raises`` tuple is forward-compatible if either is raised.
- Prior version used a ``try/except AttributeError: pass`` block
- which silently passed if NOTHING was raised.
- """
- settings = DocumentSchedulerSettings()
- with pytest.raises((AttributeError, FrozenInstanceError)):
- settings.enabled = False
-
- def test_cannot_modify_interval(self):
- settings = DocumentSchedulerSettings()
- with pytest.raises((AttributeError, FrozenInstanceError)):
- settings.interval_seconds = 900
-
- def test_is_hashable(self):
- settings = DocumentSchedulerSettings()
- # Frozen dataclasses are hashable
- hash_val = hash(settings)
- assert isinstance(hash_val, int)
-
- def test_equality(self):
- s1 = DocumentSchedulerSettings()
- s2 = DocumentSchedulerSettings()
- assert s1 == s2
-
- def test_inequality_different_values(self):
- s1 = DocumentSchedulerSettings(enabled=True)
- s2 = DocumentSchedulerSettings(enabled=False)
- assert s1 != s2
-
-
-class TestDocumentSchedulerSettingsCustom:
- """Tests for custom settings values."""
-
- def test_custom_enabled(self):
- settings = DocumentSchedulerSettings(enabled=False)
- assert settings.enabled is False
-
- def test_custom_interval(self):
- settings = DocumentSchedulerSettings(interval_seconds=900)
- assert settings.interval_seconds == 900
-
- def test_custom_download_pdfs(self):
- settings = DocumentSchedulerSettings(download_pdfs=True)
- assert settings.download_pdfs is True
-
- def test_custom_generate_rag(self):
- settings = DocumentSchedulerSettings(generate_rag=True)
- assert settings.generate_rag is True
-
- def test_custom_last_run(self):
- settings = DocumentSchedulerSettings(last_run="2025-06-15T12:00:00")
- assert settings.last_run == "2025-06-15T12:00:00"
-
- def test_all_custom(self):
- settings = DocumentSchedulerSettings(
- enabled=False,
- interval_seconds=600,
- download_pdfs=True,
- extract_text=False,
- generate_rag=True,
- last_run="2025-01-01",
- )
- assert settings.enabled is False
- assert settings.interval_seconds == 600
- assert settings.download_pdfs is True
- assert settings.extract_text is False
- assert settings.generate_rag is True
-
-
-# --- Settings cache patterns ---
-
-
-class TestSettingsCachePattern:
- """Tests for TTL cache pattern for settings."""
-
- def _get_cached_or_default(self, cache, username, default_factory):
- """Pattern for cached settings retrieval."""
- cached = cache.get(username)
- if cached is not None:
- return cached
- return default_factory()
-
- def test_returns_cached_value(self):
- cache = {"user1": DocumentSchedulerSettings(enabled=False)}
- result = self._get_cached_or_default(
- cache, "user1", DocumentSchedulerSettings.defaults
- )
- assert result.enabled is False
-
- def test_returns_default_for_missing(self):
- cache = {}
- result = self._get_cached_or_default(
- cache, "user1", DocumentSchedulerSettings.defaults
- )
- assert result.enabled is True # Default
-
- def test_none_in_cache_returns_none(self):
- # None might be stored intentionally (cache hit with None value)
- cache = {"user1": None}
- result = self._get_cached_or_default(
- cache, "user1", DocumentSchedulerSettings.defaults
- )
- # Cache hit with None value should return default since None is not "is not None"
- # Actually the check is "if cached is not None" so None returns default
- assert result.enabled is True # Returns default when cached is None
-
-
-class TestSettingsCacheInvalidation:
- """Tests for cache invalidation patterns."""
-
- def _invalidate_user(self, cache, username):
- """Invalidate cached settings for a user."""
- if username in cache:
- del cache[username]
- return True
- return False
-
- def _invalidate_all(self, cache):
- """Invalidate all cached settings."""
- count = len(cache)
- cache.clear()
- return count
-
- def test_invalidate_existing_user(self):
- cache = {"user1": {}, "user2": {}}
- result = self._invalidate_user(cache, "user1")
- assert result is True
- assert "user1" not in cache
- assert "user2" in cache
-
- def test_invalidate_missing_user(self):
- cache = {"user2": {}}
- result = self._invalidate_user(cache, "user1")
- assert result is False
-
- def test_invalidate_all_returns_count(self):
- cache = {"u1": {}, "u2": {}, "u3": {}}
- count = self._invalidate_all(cache)
- assert count == 3
- assert len(cache) == 0
-
-
-class TestSettingsCacheThreadSafety:
- """Tests for thread-safe cache access patterns."""
-
- def test_lock_acquire_release(self):
- lock = threading.Lock()
- with lock:
- # Critical section
- pass
- # Lock should be released
-
- def test_lock_reentrant_fails(self):
- lock = threading.Lock()
- lock.acquire()
- # Non-reentrant lock should fail
- result = lock.acquire(blocking=False)
- assert result is False
- lock.release()
-
-
-# --- Document processing configuration ---
-
-
-class TestDocumentProcessingConfig:
- """Tests for document processing configuration patterns."""
-
- def test_should_process_enabled(self):
- settings = DocumentSchedulerSettings(enabled=True)
- should_process = settings.enabled
- assert should_process is True
-
- def test_should_not_process_disabled(self):
- settings = DocumentSchedulerSettings(enabled=False)
- should_process = settings.enabled
- assert should_process is False
-
- def test_processing_options(self):
- settings = DocumentSchedulerSettings(
- download_pdfs=True, extract_text=True, generate_rag=True
- )
- options = {
- "download_pdfs": settings.download_pdfs,
- "extract_text": settings.extract_text,
- "generate_rag": settings.generate_rag,
- }
- assert options["download_pdfs"] is True
- assert options["extract_text"] is True
- assert options["generate_rag"] is True
-
-
-class TestIntervalCalculation:
- """Tests for processing interval calculations."""
-
- def test_interval_to_timedelta(self):
- interval_seconds = 1800
- delta = timedelta(seconds=interval_seconds)
- assert delta.total_seconds() == 1800
-
- def test_next_run_calculation(self):
- now = datetime.now(timezone.utc)
- interval_seconds = 900
- next_run = now + timedelta(seconds=interval_seconds)
- assert next_run > now
- assert (next_run - now).total_seconds() == 900
-
- def test_interval_with_jitter(self):
- base_interval = 1800
- max_jitter = 300
- # Jitter should be between 0 and max_jitter
- import random
-
- jitter = random.randint(0, max_jitter)
- total = base_interval + jitter
- assert base_interval <= total <= base_interval + max_jitter
-
-
-# --- Last run tracking ---
-
-
-class TestLastRunTracking:
- """Tests for last run timestamp tracking."""
-
- def test_format_last_run_iso(self):
- now = datetime.now(timezone.utc)
- last_run = now.isoformat()
- assert "T" in last_run
-
- def test_parse_last_run_iso(self):
- last_run = "2025-06-15T12:30:00+00:00"
- parsed = datetime.fromisoformat(last_run)
- assert parsed.hour == 12
- assert parsed.minute == 30
-
- def test_check_if_should_run(self):
- last_run = datetime.now(timezone.utc) - timedelta(hours=2)
- interval_seconds = 3600 # 1 hour
- next_due = last_run + timedelta(seconds=interval_seconds)
- now = datetime.now(timezone.utc)
- should_run = next_due <= now
- assert should_run is True
-
- def test_not_due_yet(self):
- last_run = datetime.now(timezone.utc) - timedelta(minutes=30)
- interval_seconds = 3600 # 1 hour
- next_due = last_run + timedelta(seconds=interval_seconds)
- now = datetime.now(timezone.utc)
- should_run = next_due <= now
- assert should_run is False
-
-
-# --- Document collection patterns ---
-
-
-class TestDocumentCollectionPatterns:
- """Tests for document collection handling."""
-
- def test_collection_has_documents(self):
- collection = {"id": "col1", "documents": [{"id": "d1"}, {"id": "d2"}]}
- has_docs = bool(collection.get("documents"))
- assert has_docs is True
-
- def test_empty_collection(self):
- collection = {"id": "col1", "documents": []}
- has_docs = bool(collection.get("documents"))
- assert has_docs is False
-
- def test_filter_unprocessed_documents(self):
- docs = [
- {"id": "d1", "processed": True},
- {"id": "d2", "processed": False},
- {"id": "d3", "processed": False},
- ]
- unprocessed = [d for d in docs if not d.get("processed", False)]
- assert len(unprocessed) == 2
-
- def test_mark_document_processed(self):
- doc = {"id": "d1", "processed": False}
- doc["processed"] = True
- doc["processed_at"] = datetime.now(timezone.utc).isoformat()
- assert doc["processed"] is True
-
-
-# --- RAG indexing patterns ---
-
-
-class TestRAGIndexingPatterns:
- """Tests for RAG indexing configuration patterns."""
-
- def test_should_index_check(self):
- settings = DocumentSchedulerSettings(generate_rag=True)
- should_index = settings.generate_rag
- assert should_index is True
-
- def test_skip_rag_when_disabled(self):
- settings = DocumentSchedulerSettings(generate_rag=False)
- should_index = settings.generate_rag
- assert should_index is False
-
- def test_index_only_with_text(self):
- doc = {"id": "d1", "text_content": "Some text"}
- has_text = bool(doc.get("text_content"))
- assert has_text is True
-
- def test_skip_empty_text(self):
- doc = {"id": "d1", "text_content": ""}
- has_text = bool(doc.get("text_content"))
- assert has_text is False
-
-
-# --- PDF download patterns ---
-
-
-class TestPDFDownloadPatterns:
- """Tests for PDF download configuration."""
-
- def test_should_download_check(self):
- settings = DocumentSchedulerSettings(download_pdfs=True)
- should_download = settings.download_pdfs
- assert should_download is True
-
- def test_skip_download_when_disabled(self):
- settings = DocumentSchedulerSettings(download_pdfs=False)
- should_download = settings.download_pdfs
- assert should_download is False
-
- def test_document_has_url(self):
- doc = {"id": "d1", "url": "https://example.com/doc.pdf"}
- has_url = bool(doc.get("url"))
- assert has_url is True
-
- def test_is_pdf_url(self):
- url = "https://example.com/document.pdf"
- is_pdf = url.lower().endswith(".pdf")
- assert is_pdf is True
-
- def test_not_pdf_url(self):
- url = "https://example.com/page.html"
- is_pdf = url.lower().endswith(".pdf")
- assert is_pdf is False
-
-
-# --- Text extraction patterns ---
-
-
-class TestTextExtractionPatterns:
- """Tests for text extraction configuration."""
-
- def test_should_extract_check(self):
- settings = DocumentSchedulerSettings(extract_text=True)
- should_extract = settings.extract_text
- assert should_extract is True
-
- def test_skip_extract_when_disabled(self):
- settings = DocumentSchedulerSettings(extract_text=False)
- should_extract = settings.extract_text
- assert should_extract is False
-
- def test_already_has_text(self):
- doc = {"id": "d1", "text_content": "Existing text"}
- needs_extraction = not doc.get("text_content")
- assert needs_extraction is False
-
- def test_needs_extraction(self):
- doc = {"id": "d1"}
- needs_extraction = not doc.get("text_content")
- assert needs_extraction is True
-
-
-# --- Scheduler status patterns ---
-
-
-class TestDocumentSchedulerStatus:
- """Tests for scheduler status patterns."""
-
- def _build_status(self, settings, is_running, last_run, next_run):
- return {
- "enabled": settings.enabled,
- "is_running": is_running,
- "last_run": last_run,
- "next_run": next_run,
- "interval_seconds": settings.interval_seconds,
- "processing_options": {
- "download_pdfs": settings.download_pdfs,
- "extract_text": settings.extract_text,
- "generate_rag": settings.generate_rag,
- },
- }
-
- def test_status_includes_enabled(self):
- settings = DocumentSchedulerSettings(enabled=True)
- status = self._build_status(settings, True, None, None)
- assert status["enabled"] is True
-
- def test_status_includes_running(self):
- settings = DocumentSchedulerSettings()
- status = self._build_status(settings, True, None, None)
- assert status["is_running"] is True
-
- def test_status_includes_options(self):
- settings = DocumentSchedulerSettings(download_pdfs=True)
- status = self._build_status(settings, False, None, None)
- assert status["processing_options"]["download_pdfs"] is True
-
- def test_status_includes_interval(self):
- settings = DocumentSchedulerSettings(interval_seconds=900)
- status = self._build_status(settings, False, None, None)
- assert status["interval_seconds"] == 900
-
-
-# --- Error handling patterns ---
-
-
-class TestDocumentProcessingErrors:
- """Tests for error handling in document processing."""
-
- def test_error_count_tracking(self):
- errors = {"doc1": 0}
- errors["doc1"] += 1
- assert errors["doc1"] == 1
-
- def test_max_retries_check(self):
- error_count = 3
- max_retries = 3
- should_retry = error_count < max_retries
- assert should_retry is False
-
- def test_should_retry(self):
- error_count = 1
- max_retries = 3
- should_retry = error_count < max_retries
- assert should_retry is True
-
- def test_error_backoff_calculation(self):
- base_delay = 60
- error_count = 3
- # Exponential backoff
- delay = base_delay * (2 ** (error_count - 1))
- assert delay == 240 # 60 * 2^2
-
-
-# --- Processing batch patterns ---
-
-
-class TestDocumentBatchProcessing:
- """Tests for batch document processing patterns."""
-
- def test_batch_size_limit(self):
- docs = list(range(100))
- batch_size = 10
- batch = docs[:batch_size]
- assert len(batch) == 10
-
- def test_process_in_batches(self):
- docs = list(range(25))
- batch_size = 10
- batches = [
- docs[i : i + batch_size] for i in range(0, len(docs), batch_size)
- ]
- assert len(batches) == 3
- assert len(batches[0]) == 10
- assert len(batches[1]) == 10
- assert len(batches[2]) == 5
-
- def test_empty_batch(self):
- docs = []
- batch_size = 10
- batch = docs[:batch_size]
- assert batch == []
-
-
-# --- Job scheduling patterns ---
-
-
-class TestDocumentJobScheduling:
- """Tests for document processing job scheduling."""
-
- def test_job_id_format(self):
- username = "user1"
- job_id = f"doc_process_{username}"
- assert job_id == "doc_process_user1"
-
- def test_job_exists_check(self):
- scheduled_jobs = {"doc_process_user1", "doc_process_user2"}
- job_id = "doc_process_user1"
- exists = job_id in scheduled_jobs
- assert exists is True
-
- def test_job_not_exists(self):
- scheduled_jobs = {"doc_process_user2"}
- job_id = "doc_process_user1"
- exists = job_id in scheduled_jobs
- assert exists is False
-
- def test_remove_job_from_set(self):
- scheduled_jobs = {"job1", "job2", "job3"}
- scheduled_jobs.discard("job2")
- assert "job2" not in scheduled_jobs
- assert len(scheduled_jobs) == 2
-
- def test_add_job_to_set(self):
- scheduled_jobs = {"job1"}
- scheduled_jobs.add("job2")
- assert "job2" in scheduled_jobs
diff --git a/tests/news/test_scheduler_logic_behavior.py b/tests/news/test_scheduler_logic_behavior.py
deleted file mode 100644
index e896bf35d7..0000000000
--- a/tests/news/test_scheduler_logic_behavior.py
+++ /dev/null
@@ -1,590 +0,0 @@
-"""
-Deep behavioral tests for scheduler.py pure logic.
-Tests default config, settings dataclass, singleton pattern,
-user session tracking, jitter calculation, and job ID patterns.
-"""
-
-import random
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-
-
-# --- DocumentSchedulerSettings defaults ---
-
-
-@dataclass(frozen=True)
-class TestDocumentSchedulerSettings:
- """Test copy of DocumentSchedulerSettings."""
-
- enabled: bool = True
- interval_seconds: int = 1800
- download_pdfs: bool = False
- extract_text: bool = True
- generate_rag: bool = False
- last_run: str = ""
-
- @classmethod
- def defaults(cls) -> "TestDocumentSchedulerSettings":
- return cls()
-
-
-class TestDocumentSchedulerSettingsDefaults:
- """Tests for DocumentSchedulerSettings default values."""
-
- def test_enabled_default_true(self):
- settings = TestDocumentSchedulerSettings.defaults()
- assert settings.enabled is True
-
- def test_interval_seconds_default(self):
- settings = TestDocumentSchedulerSettings.defaults()
- assert settings.interval_seconds == 1800 # 30 minutes
-
- def test_download_pdfs_default_false(self):
- settings = TestDocumentSchedulerSettings.defaults()
- assert settings.download_pdfs is False
-
- def test_extract_text_default_true(self):
- settings = TestDocumentSchedulerSettings.defaults()
- assert settings.extract_text is True
-
- def test_generate_rag_default_false(self):
- settings = TestDocumentSchedulerSettings.defaults()
- assert settings.generate_rag is False
-
- def test_last_run_default_empty(self):
- settings = TestDocumentSchedulerSettings.defaults()
- assert settings.last_run == ""
-
- def test_frozen_dataclass(self):
- settings = TestDocumentSchedulerSettings.defaults()
- try:
- settings.enabled = False # type: ignore
- assert False, "Should have raised FrozenInstanceError"
- except Exception:
- pass # Expected - frozen dataclass
-
-
-class TestDocumentSchedulerSettingsCustom:
- """Tests for custom DocumentSchedulerSettings values."""
-
- def test_custom_enabled(self):
- settings = TestDocumentSchedulerSettings(enabled=False)
- assert settings.enabled is False
-
- def test_custom_interval(self):
- settings = TestDocumentSchedulerSettings(interval_seconds=3600)
- assert settings.interval_seconds == 3600
-
- def test_custom_download_pdfs(self):
- settings = TestDocumentSchedulerSettings(download_pdfs=True)
- assert settings.download_pdfs is True
-
- def test_custom_last_run(self):
- settings = TestDocumentSchedulerSettings(
- last_run="2025-06-15T10:00:00Z"
- )
- assert settings.last_run == "2025-06-15T10:00:00Z"
-
-
-# --- Default config ---
-
-
-class TestDefaultConfig:
- """Tests for _load_default_config values."""
-
- def _load_defaults(self):
- return {
- "enabled": True,
- "retention_hours": 48,
- "cleanup_interval_hours": 1,
- "max_jitter_seconds": 300,
- "max_concurrent_jobs": 10,
- "subscription_batch_size": 5,
- "activity_check_interval_minutes": 5,
- }
-
- def test_enabled_default(self):
- config = self._load_defaults()
- assert config["enabled"] is True
-
- def test_retention_hours_default(self):
- config = self._load_defaults()
- assert config["retention_hours"] == 48
-
- def test_cleanup_interval_default(self):
- config = self._load_defaults()
- assert config["cleanup_interval_hours"] == 1
-
- def test_max_jitter_default(self):
- config = self._load_defaults()
- assert config["max_jitter_seconds"] == 300
-
- def test_max_concurrent_jobs_default(self):
- config = self._load_defaults()
- assert config["max_concurrent_jobs"] == 10
-
- def test_batch_size_default(self):
- config = self._load_defaults()
- assert config["subscription_batch_size"] == 5
-
- def test_activity_check_interval_default(self):
- config = self._load_defaults()
- assert config["activity_check_interval_minutes"] == 5
-
-
-# --- Singleton pattern ---
-
-
-class TestSingletonPattern:
- """Tests for singleton pattern logic."""
-
- def test_instance_initially_none(self):
- _instance = None
- assert _instance is None
-
- def test_instance_created(self):
- _instance = None
- if _instance is None:
- _instance = {"initialized": True}
- assert _instance is not None
-
- def test_instance_reused(self):
- _instance = {"count": 1}
- if _instance is None:
- _instance = {"count": 2}
- assert _instance["count"] == 1
-
- def test_double_check_locking(self):
- _instance = None
- if _instance is None:
- # Simulating double-check
- if _instance is None:
- _instance = {"value": "created"}
- assert _instance is not None
-
-
-# --- User session structure ---
-
-
-class TestUserSessionStructure:
- """Tests for user session data structure.
-
- Note: passwords are now stored in SchedulerCredentialStore, not in
- the session dict. Session dict only has last_activity and scheduled_jobs.
- """
-
- def _create_session(self):
- now = datetime.now(timezone.utc)
- return {
- "last_activity": now,
- "scheduled_jobs": set(),
- }
-
- def test_has_last_activity(self):
- session = self._create_session()
- assert "last_activity" in session
- assert isinstance(session["last_activity"], datetime)
-
- def test_has_empty_scheduled_jobs(self):
- session = self._create_session()
- assert session["scheduled_jobs"] == set()
-
- def test_scheduled_jobs_is_set(self):
- session = self._create_session()
- assert isinstance(session["scheduled_jobs"], set)
-
- def test_no_password_in_session(self):
- session = self._create_session()
- assert "password" not in session
-
-
-class TestUserSessionUpdate:
- """Tests for user session update logic."""
-
- def test_new_user_creates_session(self):
- sessions = {}
- username = "user1"
- if username not in sessions:
- sessions[username] = {
- "last_activity": None,
- "scheduled_jobs": set(),
- }
- assert "user1" in sessions
-
- def test_activity_time_updated(self):
- old_time = datetime(2025, 1, 1, tzinfo=timezone.utc)
- new_time = datetime(2025, 6, 15, tzinfo=timezone.utc)
- sessions = {"user1": {"last_activity": old_time}}
- sessions["user1"]["last_activity"] = new_time
- assert sessions["user1"]["last_activity"] == new_time
-
-
-# --- Jitter calculation ---
-
-
-class TestJitterCalculation:
- """Tests for jitter calculation in scheduling."""
-
- def _calc_jitter(self, max_jitter):
- return random.randint(0, max_jitter)
-
- def test_jitter_within_range(self):
- for _ in range(100):
- jitter = self._calc_jitter(300)
- assert 0 <= jitter <= 300
-
- def test_jitter_with_zero_max(self):
- jitter = self._calc_jitter(0)
- assert jitter == 0
-
- def test_jitter_with_small_max(self):
- for _ in range(50):
- jitter = self._calc_jitter(10)
- assert 0 <= jitter <= 10
-
-
-class TestJitterFromConfig:
- """Tests for getting jitter from config."""
-
- def _get_max_jitter(self, config):
- return int(config.get("max_jitter_seconds", 300))
-
- def test_from_config(self):
- config = {"max_jitter_seconds": 600}
- assert self._get_max_jitter(config) == 600
-
- def test_default_when_missing(self):
- config = {}
- assert self._get_max_jitter(config) == 300
-
- def test_converts_to_int(self):
- config = {"max_jitter_seconds": "500"}
- result = self._get_max_jitter(config)
- assert result == 500
- assert isinstance(result, int)
-
-
-# --- Job ID patterns ---
-
-
-class TestJobIdPatterns:
- """Tests for job ID construction patterns."""
-
- def _make_job_id(self, username, subscription_id):
- return f"{username}_{subscription_id}"
-
- def test_basic_job_id(self):
- result = self._make_job_id("user1", "sub123")
- assert result == "user1_sub123"
-
- def test_job_id_with_uuid(self):
- result = self._make_job_id(
- "alice", "550e8400-e29b-41d4-a716-446655440000"
- )
- assert "alice_550e8400" in result
-
- def test_job_id_unique_per_user(self):
- id1 = self._make_job_id("user1", "sub1")
- id2 = self._make_job_id("user2", "sub1")
- assert id1 != id2
-
- def test_job_id_unique_per_sub(self):
- id1 = self._make_job_id("user1", "sub1")
- id2 = self._make_job_id("user1", "sub2")
- assert id1 != id2
-
-
-class TestSystemJobIds:
- """Tests for system job ID patterns."""
-
- def test_cleanup_job_id(self):
- job_id = "cleanup_inactive_users"
- assert "cleanup" in job_id
-
- def test_reload_config_job_id(self):
- job_id = "reload_config"
- assert "config" in job_id
-
- def test_initial_cleanup_job_id(self):
- job_id = "initial_cleanup"
- assert "initial" in job_id
-
- def test_document_processing_job_id(self):
- job_id = "document_processing_user1"
- assert "document" in job_id
- assert "user1" in job_id
-
-
-# --- Retention and cleanup ---
-
-
-class TestRetentionCalculation:
- """Tests for user session retention logic."""
-
- def _is_expired(self, last_activity, retention_hours):
- cutoff = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
- return last_activity < cutoff
-
- def test_expired_session(self):
- old_time = datetime.now(timezone.utc) - timedelta(hours=50)
- assert self._is_expired(old_time, 48) is True
-
- def test_active_session(self):
- recent_time = datetime.now(timezone.utc) - timedelta(hours=1)
- assert self._is_expired(recent_time, 48) is False
-
- def test_boundary_just_under(self):
- # Just under the retention window - not expired
- just_under = datetime.now(timezone.utc) - timedelta(
- hours=47, minutes=59
- )
- assert self._is_expired(just_under, 48) is False
-
- def test_just_over_retention(self):
- just_over = datetime.now(timezone.utc) - timedelta(hours=48, seconds=1)
- assert self._is_expired(just_over, 48) is True
-
-
-# --- Scheduler state ---
-
-
-class TestSchedulerState:
- """Tests for scheduler state management."""
-
- def test_initial_not_running(self):
- is_running = False
- assert is_running is False
-
- def test_start_sets_running(self):
- is_running = False
- is_running = True
- assert is_running is True
-
- def test_stop_clears_running(self):
- is_running = True
- is_running = False
- assert is_running is False
-
- def test_double_start_prevented(self):
- is_running = True
- should_start = not is_running
- assert should_start is False
-
-
-class TestSchedulerEnabledCheck:
- """Tests for scheduler enabled/disabled logic."""
-
- def _should_start(self, config):
- return config.get("enabled", True)
-
- def test_enabled_true(self):
- assert self._should_start({"enabled": True}) is True
-
- def test_enabled_false(self):
- assert self._should_start({"enabled": False}) is False
-
- def test_default_enabled(self):
- assert self._should_start({}) is True
-
-
-# --- Settings cache patterns ---
-
-
-class TestSettingsCachePatterns:
- """Tests for settings cache logic."""
-
- def test_cache_hit(self):
- cache = {"user1": "settings"}
- result = cache.get("user1")
- assert result is not None
-
- def test_cache_miss(self):
- cache = {}
- result = cache.get("user1")
- assert result is None
-
- def test_force_refresh_bypasses_cache(self):
- cache = {"user1": "old_settings"}
- force_refresh = True
- if force_refresh:
- result = None # Force fetch
- else:
- result = cache.get("user1")
- assert result is None
-
-
-class TestCacheInvalidation:
- """Tests for cache invalidation patterns."""
-
- def test_invalidate_user(self):
- cache = {"user1": "s1", "user2": "s2"}
- if "user1" in cache:
- del cache["user1"]
- assert "user1" not in cache
- assert "user2" in cache
-
- def test_invalidate_returns_true_if_existed(self):
- cache = {"user1": "s"}
- existed = "user1" in cache
- if existed:
- del cache["user1"]
- assert existed is True
-
- def test_invalidate_returns_false_if_not_existed(self):
- cache = {}
- existed = "user1" in cache
- assert existed is False
-
- def test_invalidate_all(self):
- cache = {"user1": "s1", "user2": "s2"}
- count = len(cache)
- cache.clear()
- assert len(cache) == 0
- assert count == 2
-
-
-# --- Scheduled jobs set management ---
-
-
-class TestScheduledJobsSetManagement:
- """Tests for scheduled jobs set operations."""
-
- def test_add_job_to_set(self):
- jobs = set()
- jobs.add("job1")
- assert "job1" in jobs
-
- def test_remove_job_from_set(self):
- jobs = {"job1", "job2"}
- jobs.remove("job1")
- assert "job1" not in jobs
-
- def test_remove_with_discard(self):
- jobs = {"job1"}
- jobs.discard("job2") # No error if not present
- assert "job1" in jobs
-
- def test_copy_before_iteration(self):
- jobs = {"job1", "job2"}
- for job_id in jobs.copy():
- jobs.remove(job_id)
- assert len(jobs) == 0
-
-
-# --- Config setting retrieval ---
-
-
-class TestConfigSettingRetrieval:
- """Tests for _get_setting pattern."""
-
- def _get_setting(self, settings_manager, key, default):
- if settings_manager:
- return settings_manager.get(key, default)
- return default
-
- def test_with_manager(self):
- manager = {"news.scheduler.enabled": True}
- result = self._get_setting(manager, "news.scheduler.enabled", False)
- assert result is True
-
- def test_without_manager(self):
- result = self._get_setting(None, "news.scheduler.enabled", True)
- assert result is True
-
- def test_missing_key_uses_default(self):
- manager = {}
- result = self._get_setting(manager, "missing.key", "default_value")
- assert result == "default_value"
-
-
-# --- Activity delta calculation ---
-
-
-class TestActivityDeltaCalculation:
- """Tests for activity time delta calculation."""
-
- def _calc_delta(self, old_activity, now):
- return now - old_activity
-
- def test_one_hour_delta(self):
- old = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- now = datetime(2025, 6, 15, 11, 0, tzinfo=timezone.utc)
- delta = self._calc_delta(old, now)
- assert delta.total_seconds() == 3600
-
- def test_zero_delta(self):
- time = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- delta = self._calc_delta(time, time)
- assert delta.total_seconds() == 0
-
- def test_multi_day_delta(self):
- old = datetime(2025, 6, 10, 10, 0, tzinfo=timezone.utc)
- now = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- delta = self._calc_delta(old, now)
- assert delta.days == 5
-
-
-# --- User unregistration ---
-
-
-class TestUserUnregistration:
- """Tests for user unregistration logic."""
-
- def test_removes_from_sessions(self):
- sessions = {"user1": {}, "user2": {}}
- if "user1" in sessions:
- del sessions["user1"]
- assert "user1" not in sessions
- assert "user2" in sessions
-
- def test_clears_scheduled_jobs(self):
- session = {"scheduled_jobs": {"job1", "job2"}}
- jobs_to_remove = session["scheduled_jobs"].copy()
- assert len(jobs_to_remove) == 2
-
- def test_invalidates_cache_after_unregister(self):
- cache = {"user1": "settings"}
- # After removing user, invalidate cache
- if "user1" in cache:
- del cache["user1"]
- assert "user1" not in cache
-
-
-# --- Initial run date calculation ---
-
-
-class TestInitialRunDateCalculation:
- """Tests for initial job run date calculation."""
-
- def _calc_initial_run(self, delay_seconds):
- return datetime.now(timezone.utc) + timedelta(seconds=delay_seconds)
-
- def test_30_second_delay(self):
- before = datetime.now(timezone.utc)
- run_date = self._calc_initial_run(30)
- assert run_date > before
- assert (run_date - before).total_seconds() >= 30
- assert (run_date - before).total_seconds() < 32
-
- def test_zero_delay(self):
- run_date = self._calc_initial_run(0)
- now = datetime.now(timezone.utc)
- diff = abs((run_date - now).total_seconds())
- assert diff < 1 # Within 1 second
-
-
-# --- Stop scheduler cleanup ---
-
-
-class TestStopSchedulerCleanup:
- """Tests for cleanup during stop."""
-
- def test_clears_user_sessions(self):
- sessions = {"user1": {}, "user2": {}}
- sessions.clear()
- assert len(sessions) == 0
-
- def test_sets_not_running(self):
- is_running = True
- is_running = False
- assert is_running is False
diff --git a/tests/news/test_scheduling_patterns_behavior.py b/tests/news/test_scheduling_patterns_behavior.py
deleted file mode 100644
index 7af94fb335..0000000000
--- a/tests/news/test_scheduling_patterns_behavior.py
+++ /dev/null
@@ -1,844 +0,0 @@
-"""
-Behavioral tests for scheduling patterns.
-
-These tests verify the logic of scheduling patterns like cron expressions,
-interval calculation, job queuing, and time-based execution
-without making actual scheduler calls.
-"""
-
-import calendar
-import time
-from dataclasses import dataclass
-from datetime import datetime, timedelta
-from enum import Enum
-
-
-class TestCronParsing:
- """Tests for cron expression parsing."""
-
- def test_parse_simple_cron(self):
- """Test parsing simple cron expression."""
-
- def parse_cron(expression):
- parts = expression.split()
- if len(parts) != 5:
- return None
- return {
- "minute": parts[0],
- "hour": parts[1],
- "day_of_month": parts[2],
- "month": parts[3],
- "day_of_week": parts[4],
- }
-
- parsed = parse_cron("0 12 * * *")
- assert parsed["minute"] == "0"
- assert parsed["hour"] == "12"
- assert parsed["day_of_month"] == "*"
-
- def test_expand_cron_wildcard(self):
- """Test expanding cron wildcard."""
-
- def expand_field(field, min_val, max_val):
- if field == "*":
- return list(range(min_val, max_val + 1))
- if "," in field:
- return [int(x) for x in field.split(",")]
- if "-" in field:
- start, end = field.split("-")
- return list(range(int(start), int(end) + 1))
- if "/" in field:
- base, step = field.split("/")
- if base == "*":
- return list(range(min_val, max_val + 1, int(step)))
- return list(range(int(base), max_val + 1, int(step)))
- return [int(field)]
-
- assert expand_field("*", 0, 59) == list(range(60))
- assert expand_field("0,15,30,45", 0, 59) == [0, 15, 30, 45]
- assert expand_field("1-5", 1, 7) == [1, 2, 3, 4, 5]
- assert expand_field("*/15", 0, 59) == [0, 15, 30, 45]
- assert expand_field("10", 0, 59) == [10]
-
- def test_parse_cron_step(self):
- """Test parsing cron step values."""
-
- def parse_step(field):
- if "/" not in field:
- return None, None
- base, step = field.split("/")
- return base, int(step)
-
- base, step = parse_step("*/5")
- assert base == "*"
- assert step == 5
-
- base, step = parse_step("0/10")
- assert base == "0"
- assert step == 10
-
- def test_validate_cron_field(self):
- """Test validating cron field values."""
-
- def validate_field(field, min_val, max_val):
- if field == "*":
- return True
- try:
- for part in (
- field.replace("-", ",").replace("/", ",").split(",")
- ):
- if part != "*":
- val = int(part)
- if val < min_val or val > max_val:
- return False
- return True
- except ValueError:
- return False
-
- assert validate_field("0", 0, 59) is True
- assert validate_field("60", 0, 59) is False
- assert validate_field("0-30", 0, 59) is True
- assert validate_field("invalid", 0, 59) is False
-
- def test_cron_aliases(self):
- """Test cron expression aliases."""
-
- def expand_alias(expression):
- aliases = {
- "@yearly": "0 0 1 1 *",
- "@annually": "0 0 1 1 *",
- "@monthly": "0 0 1 * *",
- "@weekly": "0 0 * * 0",
- "@daily": "0 0 * * *",
- "@midnight": "0 0 * * *",
- "@hourly": "0 * * * *",
- }
- return aliases.get(expression, expression)
-
- assert expand_alias("@daily") == "0 0 * * *"
- assert expand_alias("@hourly") == "0 * * * *"
- assert expand_alias("0 12 * * *") == "0 12 * * *"
-
-
-class TestIntervalScheduling:
- """Tests for interval-based scheduling."""
-
- def test_calculate_next_run(self):
- """Test calculating next run time from interval."""
-
- def next_run(last_run, interval_seconds):
- if last_run is None:
- return time.time()
- return last_run + interval_seconds
-
- now = time.time()
- last = now - 100
- next_time = next_run(last, 60)
- assert next_time == last + 60
-
- # No last run - should run now
- assert next_run(None, 60) >= now
-
- def test_parse_interval_string(self):
- """Test parsing interval string to seconds."""
-
- def parse_interval(interval_str):
- units = {
- "s": 1,
- "m": 60,
- "h": 3600,
- "d": 86400,
- "w": 604800,
- }
- if not interval_str:
- return None
- unit = interval_str[-1].lower()
- if unit not in units:
- return int(interval_str)
- value = int(interval_str[:-1])
- return value * units[unit]
-
- assert parse_interval("30s") == 30
- assert parse_interval("5m") == 300
- assert parse_interval("2h") == 7200
- assert parse_interval("1d") == 86400
- assert parse_interval("60") == 60
-
- def test_interval_with_jitter(self):
- """Test adding jitter to interval."""
-
- def add_jitter(interval, max_jitter_percent=10):
- import random
-
- jitter_range = interval * max_jitter_percent / 100
- jitter = random.uniform(-jitter_range, jitter_range)
- return max(0, interval + jitter)
-
- # Can't test randomness deterministically, but can verify bounds
- interval = 100
- for _ in range(100):
- result = add_jitter(interval, max_jitter_percent=10)
- assert 90 <= result <= 110
-
- def test_align_to_interval(self):
- """Test aligning time to interval boundary."""
-
- def align_to_interval(timestamp, interval_seconds):
- return (timestamp // interval_seconds) * interval_seconds
-
- # Align to minute boundary
- ts = 1704067230 # Some arbitrary timestamp
- aligned = align_to_interval(ts, 60)
- assert aligned % 60 == 0
- assert aligned <= ts
-
- def test_is_overdue(self):
- """Test checking if scheduled task is overdue."""
-
- def is_overdue(scheduled_time, grace_period=0):
- return time.time() > scheduled_time + grace_period
-
- now = time.time()
- assert is_overdue(now - 100) is True
- assert is_overdue(now + 100) is False
- assert is_overdue(now - 50, grace_period=100) is False
-
-
-class TestJobQueuing:
- """Tests for job queue patterns."""
-
- def test_priority_queue_ordering(self):
- """Test priority queue job ordering."""
-
- def sort_by_priority(jobs):
- # Higher priority first, then by scheduled time
- return sorted(
- jobs, key=lambda j: (-j["priority"], j["scheduled_at"])
- )
-
- jobs = [
- {"id": 1, "priority": 1, "scheduled_at": 100},
- {"id": 2, "priority": 3, "scheduled_at": 100},
- {"id": 3, "priority": 2, "scheduled_at": 50},
- ]
- sorted_jobs = sort_by_priority(jobs)
- assert sorted_jobs[0]["id"] == 2 # Highest priority
- assert sorted_jobs[1]["id"] == 3 # Medium priority
- assert sorted_jobs[2]["id"] == 1 # Lowest priority
-
- def test_fifo_queue_ordering(self):
- """Test FIFO queue job ordering."""
-
- def sort_fifo(jobs):
- return sorted(jobs, key=lambda j: j["enqueued_at"])
-
- jobs = [
- {"id": 1, "enqueued_at": 300},
- {"id": 2, "enqueued_at": 100},
- {"id": 3, "enqueued_at": 200},
- ]
- sorted_jobs = sort_fifo(jobs)
- assert [j["id"] for j in sorted_jobs] == [2, 3, 1]
-
- def test_delay_queue(self):
- """Test delay queue - jobs with future execution."""
-
- def get_ready_jobs(jobs, current_time):
- return [j for j in jobs if j["run_at"] <= current_time]
-
- now = 1000
- jobs = [
- {"id": 1, "run_at": 900}, # Past - ready
- {"id": 2, "run_at": 1000}, # Now - ready
- {"id": 3, "run_at": 1100}, # Future - not ready
- ]
- ready = get_ready_jobs(jobs, now)
- assert len(ready) == 2
- assert ready[0]["id"] == 1
- assert ready[1]["id"] == 2
-
- def test_job_deduplication(self):
- """Test job deduplication by key."""
-
- def deduplicate_jobs(jobs, key_field="dedup_key"):
- seen = set()
- result = []
- for job in jobs:
- key = job.get(key_field)
- if key is None or key not in seen:
- result.append(job)
- if key is not None:
- seen.add(key)
- return result
-
- jobs = [
- {"id": 1, "dedup_key": "sync_user_1"},
- {"id": 2, "dedup_key": "sync_user_2"},
- {"id": 3, "dedup_key": "sync_user_1"}, # Duplicate
- ]
- deduped = deduplicate_jobs(jobs)
- assert len(deduped) == 2
- assert deduped[0]["id"] == 1
- assert deduped[1]["id"] == 2
-
- def test_rate_limited_queue(self):
- """Test rate-limited job release."""
-
- def get_jobs_within_rate(jobs, max_per_second, window_seconds=1):
- max_jobs = max_per_second * window_seconds
- return jobs[:max_jobs]
-
- jobs = [{"id": i} for i in range(100)]
- released = get_jobs_within_rate(jobs, max_per_second=10)
- assert len(released) == 10
-
-
-class TestTimeCalculations:
- """Tests for time calculation patterns."""
-
- def test_next_day_of_week(self):
- """Test calculating next occurrence of day of week."""
-
- def next_day_of_week(target_weekday, from_date=None):
- if from_date is None:
- from_date = datetime.now()
- current_weekday = from_date.weekday()
- days_ahead = target_weekday - current_weekday
- if days_ahead <= 0:
- days_ahead += 7
- return from_date + timedelta(days=days_ahead)
-
- # From Monday, next Friday is 4 days ahead
- monday = datetime(2024, 1, 1) # This is a Monday
- next_friday = next_day_of_week(4, monday) # 4 = Friday
- assert next_friday.weekday() == 4
- assert (next_friday - monday).days == 4
-
- def test_next_month_day(self):
- """Test calculating next occurrence of day of month."""
-
- def next_month_day(target_day, from_date=None):
- if from_date is None:
- from_date = datetime.now()
- if from_date.day < target_day:
- # Later this month
- try:
- return from_date.replace(day=target_day)
- except ValueError:
- # Day doesn't exist in this month
- pass
- # Next month
- if from_date.month == 12:
- next_month = from_date.replace(
- year=from_date.year + 1, month=1, day=1
- )
- else:
- next_month = from_date.replace(month=from_date.month + 1, day=1)
- days_in_month = calendar.monthrange(
- next_month.year, next_month.month
- )[1]
- day = min(target_day, days_in_month)
- return next_month.replace(day=day)
-
- # From Jan 5, next 15th is Jan 15
- jan_5 = datetime(2024, 1, 5)
- next_15th = next_month_day(15, jan_5)
- assert next_15th.day == 15
- assert next_15th.month == 1
-
- # From Jan 20, next 15th is Feb 15
- jan_20 = datetime(2024, 1, 20)
- next_15th = next_month_day(15, jan_20)
- assert next_15th.day == 15
- assert next_15th.month == 2
-
- def test_business_days_calculation(self):
- """Test calculating business days."""
-
- def add_business_days(from_date, days):
- current = from_date
- added = 0
- while added < days:
- current += timedelta(days=1)
- if current.weekday() < 5: # Monday = 0, Friday = 4
- added += 1
- return current
-
- monday = datetime(2024, 1, 1) # Monday
- result = add_business_days(monday, 5)
- assert result.weekday() == 0 # Should be next Monday
- assert (result - monday).days == 7 # 7 calendar days
-
- def test_time_until_next(self):
- """Test calculating time until next occurrence."""
-
- def time_until(target_time, current_time=None):
- if current_time is None:
- current_time = time.time()
- diff = target_time - current_time
- return max(0, diff)
-
- now = time.time()
- future = now + 3600
- past = now - 100
-
- assert time_until(future, now) == 3600
- assert time_until(past, now) == 0 # Past returns 0
-
- def test_round_to_time_unit(self):
- """Test rounding time to units."""
-
- def round_to_minute(dt):
- return dt.replace(second=0, microsecond=0)
-
- def round_to_hour(dt):
- return dt.replace(minute=0, second=0, microsecond=0)
-
- dt = datetime(2024, 1, 1, 12, 34, 56)
- assert round_to_minute(dt) == datetime(2024, 1, 1, 12, 34, 0)
- assert round_to_hour(dt) == datetime(2024, 1, 1, 12, 0, 0)
-
-
-class TestSchedulerState:
- """Tests for scheduler state management."""
-
- def test_job_state_transitions(self):
- """Test job state transitions."""
-
- class JobState(Enum):
- PENDING = "pending"
- SCHEDULED = "scheduled"
- RUNNING = "running"
- COMPLETED = "completed"
- FAILED = "failed"
- CANCELLED = "cancelled"
-
- def can_transition(from_state, to_state):
- valid_transitions = {
- JobState.PENDING: {JobState.SCHEDULED, JobState.CANCELLED},
- JobState.SCHEDULED: {JobState.RUNNING, JobState.CANCELLED},
- JobState.RUNNING: {JobState.COMPLETED, JobState.FAILED},
- JobState.FAILED: {JobState.SCHEDULED}, # Retry
- }
- return to_state in valid_transitions.get(from_state, set())
-
- assert can_transition(JobState.PENDING, JobState.SCHEDULED) is True
- assert can_transition(JobState.PENDING, JobState.RUNNING) is False
- assert can_transition(JobState.RUNNING, JobState.COMPLETED) is True
- assert can_transition(JobState.COMPLETED, JobState.RUNNING) is False
-
- def test_track_job_execution(self):
- """Test tracking job execution history."""
-
- @dataclass
- class JobExecution:
- job_id: str
- started_at: float
- completed_at: float = None
- success: bool = None
- error: str = None
-
- @property
- def duration(self):
- if self.completed_at is None:
- return None
- return self.completed_at - self.started_at
-
- execution = JobExecution(job_id="job1", started_at=1000)
- assert execution.duration is None
-
- execution.completed_at = 1005
- execution.success = True
- assert execution.duration == 5
-
- def test_calculate_next_retry(self):
- """Test calculating next retry time with backoff."""
-
- def next_retry_time(attempt, base_delay=60, max_delay=3600):
- delay = base_delay * (2 ** (attempt - 1))
- delay = min(delay, max_delay)
- return time.time() + delay
-
- now = time.time()
- retry1 = next_retry_time(1)
- retry2 = next_retry_time(2)
- retry3 = next_retry_time(3)
-
- assert retry1 >= now + 60
- assert retry2 >= now + 120
- assert retry3 >= now + 240
-
- def test_job_timeout_check(self):
- """Test checking if job has timed out."""
-
- def is_timed_out(started_at, timeout_seconds):
- return time.time() > started_at + timeout_seconds
-
- now = time.time()
- assert is_timed_out(now - 100, timeout_seconds=60) is True
- assert is_timed_out(now - 30, timeout_seconds=60) is False
-
- def test_max_concurrent_jobs(self):
- """Test checking concurrent job limit."""
-
- def can_start_job(running_jobs, max_concurrent):
- return len(running_jobs) < max_concurrent
-
- running = [{"id": 1}, {"id": 2}]
- assert can_start_job(running, max_concurrent=3) is True
- assert can_start_job(running, max_concurrent=2) is False
-
-
-class TestRecurrencePatterns:
- """Tests for recurrence pattern handling."""
-
- def test_parse_recurrence_rule(self):
- """Test parsing recurrence rule."""
-
- def parse_rrule(rule_string):
- parts = rule_string.split(";")
- rule = {}
- for part in parts:
- if "=" in part:
- key, value = part.split("=")
- if key == "FREQ":
- rule["frequency"] = value.lower()
- elif key == "INTERVAL":
- rule["interval"] = int(value)
- elif key == "COUNT":
- rule["count"] = int(value)
- elif key == "BYDAY":
- rule["by_day"] = value.split(",")
- return rule
-
- rule = parse_rrule("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,WE,FR")
- assert rule["frequency"] == "weekly"
- assert rule["interval"] == 2
- assert rule["by_day"] == ["MO", "WE", "FR"]
-
- def test_daily_recurrence(self):
- """Test daily recurrence calculation."""
-
- def next_daily(from_date, interval=1):
- return from_date + timedelta(days=interval)
-
- start = datetime(2024, 1, 1)
- next_date = next_daily(start, interval=2)
- assert next_date == datetime(2024, 1, 3)
-
- def test_weekly_recurrence(self):
- """Test weekly recurrence calculation."""
-
- def next_weekly(from_date, interval=1):
- return from_date + timedelta(weeks=interval)
-
- start = datetime(2024, 1, 1)
- next_date = next_weekly(start, interval=2)
- assert next_date == datetime(2024, 1, 15)
-
- def test_monthly_recurrence(self):
- """Test monthly recurrence calculation."""
-
- def next_monthly(from_date, interval=1):
- year = from_date.year
- month = from_date.month + interval
- while month > 12:
- month -= 12
- year += 1
- day = min(from_date.day, calendar.monthrange(year, month)[1])
- return from_date.replace(year=year, month=month, day=day)
-
- start = datetime(2024, 1, 31)
- next_date = next_monthly(start, interval=1)
- assert next_date.month == 2
- assert next_date.day == 29 # Feb 2024 has 29 days
-
- def test_recurrence_end_condition(self):
- """Test recurrence end conditions."""
-
- def should_continue(
- occurrences, max_count=None, end_date=None, current_date=None
- ):
- if max_count is not None and occurrences >= max_count:
- return False
- if end_date is not None and current_date is not None:
- if current_date > end_date:
- return False
- return True
-
- assert should_continue(5, max_count=10) is True
- assert should_continue(10, max_count=10) is False
-
- end = datetime(2024, 12, 31)
- assert (
- should_continue(5, end_date=end, current_date=datetime(2024, 6, 1))
- is True
- )
- assert (
- should_continue(5, end_date=end, current_date=datetime(2025, 1, 1))
- is False
- )
-
-
-class TestTimezones:
- """Tests for timezone handling in scheduling."""
-
- def test_utc_offset_calculation(self):
- """Test UTC offset calculation."""
-
- def apply_offset(utc_time, offset_hours):
- return utc_time + timedelta(hours=offset_hours)
-
- utc = datetime(2024, 1, 1, 12, 0, 0)
- # EST is UTC-5
- est = apply_offset(utc, -5)
- assert est.hour == 7
-
- # JST is UTC+9
- jst = apply_offset(utc, 9)
- assert jst.hour == 21
-
- def test_dst_aware_scheduling(self):
- """Test DST-aware scheduling."""
-
- def is_dst_transition_day(date, dst_transitions):
- date_str = date.strftime("%Y-%m-%d")
- return date_str in dst_transitions
-
- dst_transitions = {"2024-03-10", "2024-11-03"} # US DST dates
-
- assert (
- is_dst_transition_day(datetime(2024, 3, 10), dst_transitions)
- is True
- )
- assert (
- is_dst_transition_day(datetime(2024, 3, 11), dst_transitions)
- is False
- )
-
- def test_timezone_conversion(self):
- """Test timezone name to offset conversion."""
-
- def get_offset(timezone_name):
- offsets = {
- "UTC": 0,
- "EST": -5,
- "PST": -8,
- "JST": 9,
- "GMT": 0,
- "CET": 1,
- }
- return offsets.get(timezone_name, 0)
-
- assert get_offset("EST") == -5
- assert get_offset("JST") == 9
- assert get_offset("unknown") == 0
-
- def test_schedule_in_local_time(self):
- """Test scheduling in local time."""
-
- def to_utc(local_time, utc_offset):
- return local_time - timedelta(hours=utc_offset)
-
- # Schedule for 9am EST
- local_9am = datetime(2024, 1, 1, 9, 0, 0)
- utc_time = to_utc(local_9am, utc_offset=-5)
- assert utc_time.hour == 14 # 9am EST = 2pm UTC
-
- def test_cross_day_timezone_handling(self):
- """Test handling schedule that crosses day boundary."""
-
- def adjust_for_timezone(utc_time, offset):
- adjusted = utc_time + timedelta(hours=offset)
- day_diff = adjusted.day - utc_time.day
- return adjusted, day_diff
-
- # 11pm UTC -> next day in JST (+9)
- utc_11pm = datetime(2024, 1, 1, 23, 0, 0)
- jst_time, day_diff = adjust_for_timezone(utc_11pm, 9)
- assert jst_time.hour == 8
- assert day_diff == 1
-
-
-class TestScheduleConflicts:
- """Tests for schedule conflict detection."""
-
- def test_detect_overlap(self):
- """Test detecting schedule overlaps."""
-
- def has_overlap(schedule1, schedule2):
- # Each schedule has start and end times
- start1, end1 = schedule1
- start2, end2 = schedule2
- return start1 < end2 and start2 < end1
-
- # Overlapping
- assert has_overlap((100, 200), (150, 250)) is True
- # Non-overlapping
- assert has_overlap((100, 200), (200, 300)) is False
- # One contains other
- assert has_overlap((100, 300), (150, 200)) is True
-
- def test_find_next_available_slot(self):
- """Test finding next available time slot."""
-
- def find_slot(existing_schedules, duration, start_from):
- existing_schedules = sorted(existing_schedules, key=lambda x: x[0])
- current = start_from
-
- for start, end in existing_schedules:
- if current + duration <= start:
- return current # Found a gap
- current = max(current, end)
-
- return current # After all existing schedules
-
- schedules = [(100, 150), (200, 250)]
- # Find a 40-minute slot - fits before first schedule (0+40=40 <= 100)
- slot = find_slot(schedules, duration=40, start_from=0)
- assert slot == 0 # Can fit before first schedule
-
- # Find a 60-minute slot - fits before first schedule (0+60=60 <= 100)
- slot = find_slot(schedules, duration=60, start_from=0)
- assert slot == 0 # Still fits before first schedule
-
- # Find a 110-minute slot - doesn't fit anywhere except after all
- slot = find_slot(schedules, duration=110, start_from=0)
- assert slot == 250 # Must be after all schedules
-
- def test_merge_overlapping_schedules(self):
- """Test merging overlapping schedules."""
-
- def merge_schedules(schedules):
- if not schedules:
- return []
- sorted_schedules = sorted(schedules, key=lambda x: x[0])
- merged = [sorted_schedules[0]]
-
- for start, end in sorted_schedules[1:]:
- last_start, last_end = merged[-1]
- if start <= last_end:
- merged[-1] = (last_start, max(last_end, end))
- else:
- merged.append((start, end))
- return merged
-
- schedules = [(100, 200), (150, 250), (300, 400)]
- merged = merge_schedules(schedules)
- assert len(merged) == 2
- assert merged[0] == (100, 250)
- assert merged[1] == (300, 400)
-
- def test_conflict_resolution_priority(self):
- """Test resolving conflicts by priority."""
-
- def resolve_conflict(schedules):
- # Higher priority wins
- sorted_by_priority = sorted(
- schedules, key=lambda x: x.get("priority", 0), reverse=True
- )
- result = []
- occupied = []
-
- for schedule in sorted_by_priority:
- start, end = schedule["start"], schedule["end"]
- has_conflict = any(s < end and e > start for s, e in occupied)
- if not has_conflict:
- result.append(schedule)
- occupied.append((start, end))
-
- return result
-
- schedules = [
- {"id": 1, "start": 100, "end": 200, "priority": 1},
- {
- "id": 2,
- "start": 150,
- "end": 250,
- "priority": 2,
- }, # Higher priority
- {"id": 3, "start": 300, "end": 400, "priority": 1},
- ]
- resolved = resolve_conflict(schedules)
- assert len(resolved) == 2
- assert resolved[0]["id"] == 2 # Higher priority kept
- assert resolved[1]["id"] == 3 # No conflict
-
-
-class TestMaintenanceWindows:
- """Tests for maintenance window handling."""
-
- def test_is_in_maintenance_window(self):
- """Test checking if time is in maintenance window."""
-
- def is_maintenance_time(current_time, windows):
- for window in windows:
- start_hour, end_hour = window
- current_hour = current_time.hour
- if start_hour <= end_hour:
- if start_hour <= current_hour < end_hour:
- return True
- else: # Crosses midnight
- if current_hour >= start_hour or current_hour < end_hour:
- return True
- return False
-
- # Maintenance window 2am-4am
- windows = [(2, 4)]
- assert is_maintenance_time(datetime(2024, 1, 1, 3, 0), windows) is True
- assert is_maintenance_time(datetime(2024, 1, 1, 5, 0), windows) is False
-
- # Window crossing midnight 23:00-02:00
- windows = [(23, 2)]
- assert (
- is_maintenance_time(datetime(2024, 1, 1, 23, 30), windows) is True
- )
- assert is_maintenance_time(datetime(2024, 1, 1, 1, 0), windows) is True
- assert (
- is_maintenance_time(datetime(2024, 1, 1, 10, 0), windows) is False
- )
-
- def test_delay_until_after_maintenance(self):
- """Test delaying job until after maintenance."""
-
- def delay_if_maintenance(scheduled_time, maintenance_end):
- if scheduled_time < maintenance_end:
- return maintenance_end
- return scheduled_time
-
- maintenance_end = datetime(2024, 1, 1, 4, 0)
- scheduled = datetime(2024, 1, 1, 3, 0)
- delayed = delay_if_maintenance(scheduled, maintenance_end)
- assert delayed == maintenance_end
-
- def test_skip_maintenance_days(self):
- """Test skipping certain days for maintenance."""
-
- def is_maintenance_day(date, maintenance_days):
- return date.weekday() in maintenance_days
-
- # Sunday maintenance (weekday 6)
- maintenance_days = {6}
- assert (
- is_maintenance_day(datetime(2024, 1, 7), maintenance_days) is True
- )
- assert (
- is_maintenance_day(datetime(2024, 1, 8), maintenance_days) is False
- )
-
- def test_blackout_periods(self):
- """Test blackout period handling."""
-
- def is_blackout(date, blackout_periods):
- for start, end in blackout_periods:
- if start <= date <= end:
- return True
- return False
-
- blackouts = [
- (datetime(2024, 12, 23), datetime(2024, 12, 26)), # Christmas
- (datetime(2024, 12, 31), datetime(2025, 1, 2)), # New Year
- ]
-
- assert is_blackout(datetime(2024, 12, 24), blackouts) is True
- assert is_blackout(datetime(2024, 12, 15), blackouts) is False
diff --git a/tests/news/test_search_integration_logic_behavior.py b/tests/news/test_search_integration_logic_behavior.py
deleted file mode 100644
index 7f2b2fdee2..0000000000
--- a/tests/news/test_search_integration_logic_behavior.py
+++ /dev/null
@@ -1,303 +0,0 @@
-"""
-Deep behavioral tests for search_integration.py.
-Tests NewsSearchCallback, quality calculation, search wrapper,
-and tracking logic patterns.
-"""
-
-import uuid
-from datetime import datetime, timezone
-
-
-# --- Quality calculation ---
-
-
-class TestQualityCalculation:
- """Tests for _calculate_quality heuristic."""
-
- def _calc_quality(self, result):
- findings = result.get("findings", [])
- if not findings:
- return 0.0
- count_score = min(len(findings) / 10, 1.0)
- has_content = any(f.get("content") for f in findings[:5])
- content_score = 1.0 if has_content else 0.5
- return (count_score + content_score) / 2
-
- def test_no_findings(self):
- assert self._calc_quality({}) == 0.0
-
- def test_empty_findings(self):
- assert self._calc_quality({"findings": []}) == 0.0
-
- def test_one_finding_no_content(self):
- result = {"findings": [{"title": "A"}]}
- score = self._calc_quality(result)
- # count_score = 1/10 = 0.1, content_score = 0.5
- assert score == (0.1 + 0.5) / 2
-
- def test_one_finding_with_content(self):
- result = {"findings": [{"content": "Full text"}]}
- score = self._calc_quality(result)
- # count_score = 0.1, content_score = 1.0
- assert score == (0.1 + 1.0) / 2
-
- def test_ten_findings_max_count_score(self):
- result = {"findings": [{"title": f"F{i}"} for i in range(10)]}
- score = self._calc_quality(result)
- # count_score = 10/10 = 1.0, content_score = 0.5 (no content)
- assert score == (1.0 + 0.5) / 2
-
- def test_more_than_ten_capped(self):
- result = {"findings": [{"title": f"F{i}"} for i in range(20)]}
- score = self._calc_quality(result)
- # count_score = min(20/10, 1.0) = 1.0
- assert score == (1.0 + 0.5) / 2
-
- def test_content_check_only_first_5(self):
- findings = [{"title": f"F{i}"} for i in range(10)]
- findings[7]["content"] = "Late content" # After index 5
- result = {"findings": findings}
- score = self._calc_quality(result)
- # Only checks first 5 - no content found in first 5
- assert score == (1.0 + 0.5) / 2
-
- def test_content_in_first_5(self):
- findings = [{"title": f"F{i}"} for i in range(10)]
- findings[3]["content"] = "Has content"
- result = {"findings": findings}
- score = self._calc_quality(result)
- assert score == (1.0 + 1.0) / 2
-
- def test_five_findings_with_content(self):
- result = {"findings": [{"content": "text"} for _ in range(5)]}
- score = self._calc_quality(result)
- # count_score = 5/10 = 0.5, content_score = 1.0
- assert score == (0.5 + 1.0) / 2
-
- def test_max_quality(self):
- result = {"findings": [{"content": "text"} for _ in range(10)]}
- score = self._calc_quality(result)
- assert score == 1.0
-
-
-# --- Tracking enabled logic ---
-
-
-class TestTrackingEnabled:
- """Tests for tracking_enabled property logic."""
-
- def test_default_is_false(self):
- enabled = None
- if enabled is None:
- enabled = False
- assert enabled is False
-
- def test_cached_after_first_check(self):
- enabled = None
- # First check
- if enabled is None:
- enabled = False
- # Second check uses cached
- assert enabled is False
-
- def test_can_be_set_true(self):
- enabled = True
- assert enabled is True
-
-
-# --- Search context building ---
-
-
-class TestSearchContextBuilding:
- """Tests for search wrapper context construction."""
-
- def _build_context(
- self, is_user_search=True, is_news_search=False, user_id="anonymous"
- ):
- search_id = str(uuid.uuid4())
- return {
- "is_user_search": is_user_search and not is_news_search,
- "is_news_search": is_news_search,
- "user_id": user_id,
- "search_id": search_id,
- "timestamp": datetime.now(timezone.utc),
- }
-
- def test_user_search_default(self):
- ctx = self._build_context()
- assert ctx["is_user_search"] is True
- assert ctx["is_news_search"] is False
-
- def test_news_search_overrides_user(self):
- ctx = self._build_context(is_user_search=True, is_news_search=True)
- assert ctx["is_user_search"] is False
- assert ctx["is_news_search"] is True
-
- def test_not_user_search(self):
- ctx = self._build_context(is_user_search=False)
- assert ctx["is_user_search"] is False
-
- def test_user_id_preserved(self):
- ctx = self._build_context(user_id="user42")
- assert ctx["user_id"] == "user42"
-
- def test_default_anonymous_user(self):
- ctx = self._build_context()
- assert ctx["user_id"] == "anonymous"
-
- def test_has_search_id(self):
- ctx = self._build_context()
- assert "search_id" in ctx
- assert len(ctx["search_id"]) > 0
-
- def test_has_timestamp(self):
- ctx = self._build_context()
- assert isinstance(ctx["timestamp"], datetime)
-
- def test_unique_search_ids(self):
- ctx1 = self._build_context()
- ctx2 = self._build_context()
- assert ctx1["search_id"] != ctx2["search_id"]
-
-
-# --- Callback invocation logic ---
-
-
-class TestCallbackInvocation:
- """Tests for callback __call__ logic patterns."""
-
- def _should_track(self, context, tracking_enabled):
- is_user_search = context.get("is_user_search", True)
- return is_user_search and tracking_enabled
-
- def test_tracks_when_user_search_and_enabled(self):
- ctx = {"is_user_search": True}
- assert self._should_track(ctx, True) is True
-
- def test_no_track_when_disabled(self):
- ctx = {"is_user_search": True}
- assert self._should_track(ctx, False) is False
-
- def test_no_track_when_not_user_search(self):
- ctx = {"is_user_search": False}
- assert self._should_track(ctx, True) is False
-
- def test_no_track_both_false(self):
- ctx = {"is_user_search": False}
- assert self._should_track(ctx, False) is False
-
- def test_default_is_user_search_true(self):
- ctx = {}
- assert self._should_track(ctx, True) is True
-
-
-# --- Context extraction defaults ---
-
-
-class TestContextExtractionDefaults:
- """Tests for context dict default extraction."""
-
- def _extract(self, context):
- context = context or {}
- return {
- "is_user_search": context.get("is_user_search", True),
- "user_id": context.get("user_id", "anonymous"),
- "search_id": context.get("search_id", str(uuid.uuid4())),
- }
-
- def test_none_context(self):
- result = self._extract(None)
- assert result["is_user_search"] is True
- assert result["user_id"] == "anonymous"
-
- def test_empty_context(self):
- result = self._extract({})
- assert result["is_user_search"] is True
- assert result["user_id"] == "anonymous"
-
- def test_provided_values(self):
- ctx = {"is_user_search": False, "user_id": "u1", "search_id": "s1"}
- result = self._extract(ctx)
- assert result["is_user_search"] is False
- assert result["user_id"] == "u1"
- assert result["search_id"] == "s1"
-
- def test_partial_context(self):
- result = self._extract({"user_id": "u1"})
- assert result["is_user_search"] is True
- assert result["user_id"] == "u1"
-
-
-# --- Wrapper metadata preservation ---
-
-
-class TestWrapperMetadataPreservation:
- """Tests for search wrapper metadata preservation patterns."""
-
- def test_preserves_function_name(self):
- def original_search(self, query, **kwargs):
- """Original docstring."""
- pass
-
- # Simulate wrapper
- def wrapped(self, query, **kwargs):
- pass
-
- wrapped.__name__ = original_search.__name__
- wrapped.__doc__ = original_search.__doc__
-
- assert wrapped.__name__ == "original_search"
- assert wrapped.__doc__ == "Original docstring."
-
- def test_preserves_none_doc(self):
- def original():
- pass
-
- def wrapper():
- return None
-
- original.__doc__ = None
- wrapper.__name__ = original.__name__
- wrapper.__doc__ = original.__doc__
- assert wrapper.__doc__ is None
-
-
-# --- Kwargs extraction in wrapper ---
-
-
-class TestKwargsExtraction:
- """Tests for kwargs popping in wrapper."""
-
- def test_pop_removes_key(self):
- kwargs = {"is_user_search": True, "mode": "quick"}
- is_user = kwargs.pop("is_user_search", True)
- assert is_user is True
- assert "is_user_search" not in kwargs
-
- def test_pop_default_when_missing(self):
- kwargs = {"mode": "quick"}
- is_user = kwargs.pop("is_user_search", True)
- assert is_user is True
-
- def test_pop_is_news_search(self):
- kwargs = {"is_news_search": True}
- is_news = kwargs.pop("is_news_search", False)
- assert is_news is True
-
- def test_pop_user_id(self):
- kwargs = {"user_id": "u42"}
- uid = kwargs.pop("user_id", "anonymous")
- assert uid == "u42"
-
- def test_remaining_kwargs_passed_through(self):
- kwargs = {
- "is_user_search": True,
- "is_news_search": False,
- "user_id": "u1",
- "mode": "quick",
- "depth": 3,
- }
- kwargs.pop("is_user_search", True)
- kwargs.pop("is_news_search", False)
- kwargs.pop("user_id", "anonymous")
- assert kwargs == {"mode": "quick", "depth": 3}
diff --git a/tests/news/test_search_subscription_logic_behavior.py b/tests/news/test_search_subscription_logic_behavior.py
deleted file mode 100644
index c53d5b5087..0000000000
--- a/tests/news/test_search_subscription_logic_behavior.py
+++ /dev/null
@@ -1,528 +0,0 @@
-"""
-Deep behavioral tests for search_subscription.py pure logic.
-Tests query transformation, evolution, statistics calculation,
-and factory methods.
-"""
-
-
-# --- Query transformation detection ---
-
-
-class TestQueryTransformationDetection:
- """Tests for detecting if query needs transformation."""
-
- def _needs_transform(self, query):
- query_lower = query.lower()
- return not any(
- term in query_lower
- for term in ["news", "latest", "recent", "today"]
- )
-
- def test_query_without_news_terms(self):
- assert self._needs_transform("AI research") is True
-
- def test_query_with_news(self):
- assert self._needs_transform("AI news") is False
-
- def test_query_with_latest(self):
- assert self._needs_transform("latest developments") is False
-
- def test_query_with_recent(self):
- assert self._needs_transform("recent updates") is False
-
- def test_query_with_today(self):
- assert self._needs_transform("events today") is False
-
- def test_case_insensitive(self):
- assert self._needs_transform("AI NEWS") is False
- assert self._needs_transform("LATEST TRENDS") is False
-
-
-# --- Query type detection ---
-
-
-class TestQueryTypeDetection:
- """Tests for detecting query type for transformation."""
-
- def _is_technical_query(self, query):
- query_lower = query.lower()
- return any(
- term in query_lower for term in ["how to", "tutorial", "guide"]
- )
-
- def _is_security_query(self, query):
- query_lower = query.lower()
- return any(
- term in query_lower
- for term in ["vulnerability", "security", "breach"]
- )
-
- def test_technical_how_to(self):
- assert self._is_technical_query("how to install python") is True
-
- def test_technical_tutorial(self):
- assert self._is_technical_query("python tutorial") is True
-
- def test_technical_guide(self):
- assert self._is_technical_query("deployment guide") is True
-
- def test_not_technical(self):
- assert self._is_technical_query("AI research") is False
-
- def test_security_vulnerability(self):
- assert self._is_security_query("log4j vulnerability") is True
-
- def test_security_breach(self):
- assert self._is_security_query("data breach 2025") is True
-
- def test_security_security(self):
- assert self._is_security_query("cybersecurity trends") is True
-
- def test_not_security(self):
- assert self._is_security_query("python programming") is False
-
-
-# --- Query transformation ---
-
-
-class TestQueryTransformation:
- """Tests for _transform_to_news_query logic."""
-
- def _transform_to_news_query(self, query):
- query_lower = query.lower()
-
- # Don't double-add news terms
- if any(
- term in query_lower
- for term in ["news", "latest", "recent", "today"]
- ):
- return query
-
- # Technical queries
- if any(term in query_lower for term in ["how to", "tutorial", "guide"]):
- return f"{query} latest updates developments"
-
- # Security queries
- if any(
- term in query_lower
- for term in ["vulnerability", "security", "breach"]
- ):
- return f"{query} breaking news alerts today"
-
- # General queries
- return f"{query} latest news developments"
-
- def test_already_has_news(self):
- result = self._transform_to_news_query("AI news")
- assert result == "AI news"
-
- def test_technical_query(self):
- result = self._transform_to_news_query("how to deploy docker")
- assert "latest updates developments" in result
-
- def test_security_query(self):
- result = self._transform_to_news_query("log4j vulnerability")
- assert "breaking news alerts today" in result
-
- def test_general_query(self):
- result = self._transform_to_news_query("machine learning")
- assert "latest news developments" in result
-
- def test_preserves_original(self):
- result = self._transform_to_news_query("AI research")
- assert "AI research" in result
-
-
-# --- Date placeholder replacement ---
-
-
-class TestDatePlaceholderReplacement:
- """Tests for YYYY-MM-DD placeholder replacement."""
-
- def _replace_date_placeholder(self, query, current_date):
- return query.replace("YYYY-MM-DD", current_date)
-
- def test_replaces_placeholder(self):
- query = "news from YYYY-MM-DD"
- result = self._replace_date_placeholder(query, "2025-06-15")
- assert result == "news from 2025-06-15"
-
- def test_no_placeholder(self):
- query = "AI news today"
- result = self._replace_date_placeholder(query, "2025-06-15")
- assert result == "AI news today"
-
- def test_multiple_placeholders(self):
- query = "events YYYY-MM-DD to YYYY-MM-DD"
- result = self._replace_date_placeholder(query, "2025-06-15")
- assert result == "events 2025-06-15 to 2025-06-15"
-
-
-# --- Query evolution ---
-
-
-class TestQueryEvolution:
- """Tests for evolve_query logic."""
-
- def _evolve_query(
- self, original_query, current_query, query_history, new_terms
- ):
- if new_terms:
- evolved_query = f"{original_query} {new_terms}"
- query_history.append(evolved_query)
- return evolved_query
- return current_query
-
- def test_adds_new_terms(self):
- history = ["AI news"]
- result = self._evolve_query("AI news", "AI news", history, "GPT-4")
- assert result == "AI news GPT-4"
-
- def test_appends_to_history(self):
- history = ["AI news"]
- self._evolve_query("AI news", "AI news", history, "GPT-4")
- assert len(history) == 2
- assert "AI news GPT-4" in history
-
- def test_no_change_without_terms(self):
- history = ["AI news"]
- result = self._evolve_query("AI news", "AI news", history, None)
- assert result == "AI news"
-
- def test_empty_terms_no_change(self):
- history = ["AI news"]
- result = self._evolve_query("AI news", "AI news", history, "")
- assert result == "AI news"
-
-
-# --- Statistics calculation ---
-
-
-class TestStatisticsCalculation:
- """Tests for get_statistics logic."""
-
- def _calc_success_rate(self, refresh_count, error_count):
- total = refresh_count + error_count
- if total > 0:
- return refresh_count / total
- return 0
-
- def test_all_success(self):
- rate = self._calc_success_rate(10, 0)
- assert rate == 1.0
-
- def test_half_success(self):
- rate = self._calc_success_rate(5, 5)
- assert rate == 0.5
-
- def test_no_refreshes(self):
- rate = self._calc_success_rate(0, 0)
- assert rate == 0
-
- def test_all_errors(self):
- rate = self._calc_success_rate(0, 10)
- assert rate == 0.0
-
-
-class TestQueryEvolutionCount:
- """Tests for query evolution count."""
-
- def _evolution_count(self, query_history):
- return len(query_history) - 1
-
- def test_no_evolution(self):
- history = ["original"]
- assert self._evolution_count(history) == 0
-
- def test_one_evolution(self):
- history = ["original", "evolved"]
- assert self._evolution_count(history) == 1
-
- def test_multiple_evolutions(self):
- history = ["v1", "v2", "v3", "v4"]
- assert self._evolution_count(history) == 3
-
-
-class TestStatisticsStructure:
- """Tests for statistics dictionary structure."""
-
- def _get_statistics(
- self,
- original_query,
- current_query,
- query_history,
- refresh_count,
- error_count,
- ):
- return {
- "original_query": original_query,
- "current_query": current_query,
- "query_evolution_count": len(query_history) - 1,
- "total_refreshes": refresh_count,
- "success_rate": (
- refresh_count / (refresh_count + error_count)
- if (refresh_count + error_count) > 0
- else 0
- ),
- }
-
- def test_has_original_query(self):
- stats = self._get_statistics("AI", "AI news", ["AI", "AI news"], 5, 1)
- assert stats["original_query"] == "AI"
-
- def test_has_current_query(self):
- stats = self._get_statistics("AI", "AI news", ["AI", "AI news"], 5, 1)
- assert stats["current_query"] == "AI news"
-
- def test_has_evolution_count(self):
- stats = self._get_statistics("AI", "AI news", ["AI", "AI news"], 5, 1)
- assert stats["query_evolution_count"] == 1
-
-
-# --- To dict conversion ---
-
-
-class TestToDictConversion:
- """Tests for to_dict data structure."""
-
- def _build_search_subscription_dict(
- self,
- base_dict,
- original_query,
- current_query,
- transform_enabled,
- query_history,
- statistics,
- ):
- data = base_dict.copy()
- data.update(
- {
- "original_query": original_query,
- "current_query": current_query,
- "transform_to_news_query": transform_enabled,
- "query_history": query_history,
- "statistics": statistics,
- }
- )
- return data
-
- def test_includes_original_query(self):
- result = self._build_search_subscription_dict(
- {}, "AI", "AI news", True, ["AI"], {}
- )
- assert result["original_query"] == "AI"
-
- def test_includes_transform_flag(self):
- result = self._build_search_subscription_dict(
- {}, "AI", "AI news", True, ["AI"], {}
- )
- assert result["transform_to_news_query"] is True
-
- def test_includes_query_history(self):
- result = self._build_search_subscription_dict(
- {}, "AI", "AI news", True, ["AI", "AI news"], {}
- )
- assert len(result["query_history"]) == 2
-
-
-# --- Metadata structure ---
-
-
-class TestMetadataStructure:
- """Tests for metadata dictionary structure."""
-
- def _build_metadata(self, query, transform_enabled):
- return {
- "subscription_type": "search",
- "original_query": query,
- "transform_enabled": transform_enabled,
- }
-
- def test_has_subscription_type(self):
- metadata = self._build_metadata("AI", True)
- assert metadata["subscription_type"] == "search"
-
- def test_has_original_query(self):
- metadata = self._build_metadata("AI news", True)
- assert metadata["original_query"] == "AI news"
-
- def test_has_transform_enabled(self):
- metadata = self._build_metadata("AI", False)
- assert metadata["transform_enabled"] is False
-
-
-# --- Source creation ---
-
-
-class TestSourceCreation:
- """Tests for CardSource creation in SearchSubscription."""
-
- def _create_default_source(self, query):
- return {
- "type": "user_search",
- "source_id": None,
- "created_from": f"Search subscription: {query}",
- "metadata": {},
- }
-
- def test_source_type(self):
- source = self._create_default_source("AI")
- assert source["type"] == "user_search"
-
- def test_created_from_includes_query(self):
- source = self._create_default_source("machine learning")
- assert "machine learning" in source["created_from"]
-
-
-# --- Factory: from_user_search ---
-
-
-class TestFactoryFromUserSearch:
- """Tests for SearchSubscriptionFactory.from_user_search."""
-
- def _build_source_from_search(
- self,
- search_query,
- search_result_id,
- search_timestamp=None,
- search_strategy=None,
- ):
- return {
- "type": "user_search",
- "source_id": search_result_id,
- "created_from": f"Your search: '{search_query}'",
- "metadata": {
- "search_timestamp": search_timestamp,
- "search_strategy": search_strategy,
- },
- }
-
- def test_source_type_user_search(self):
- source = self._build_source_from_search("AI", "s123")
- assert source["type"] == "user_search"
-
- def test_created_from_format(self):
- source = self._build_source_from_search("machine learning", "s123")
- assert source["created_from"] == "Your search: 'machine learning'"
-
- def test_includes_search_result_id(self):
- source = self._build_source_from_search("AI", "search-456")
- assert source["source_id"] == "search-456"
-
- def test_includes_metadata(self):
- source = self._build_source_from_search(
- "AI", "s1", search_timestamp="2025-06-15", search_strategy="quick"
- )
- assert source["metadata"]["search_timestamp"] == "2025-06-15"
- assert source["metadata"]["search_strategy"] == "quick"
-
-
-# --- Factory: from_recommendation ---
-
-
-class TestFactoryFromRecommendation:
- """Tests for SearchSubscriptionFactory.from_recommendation."""
-
- def _build_source_from_recommendation(
- self, recommendation_source, recommendation_type="topic_based"
- ):
- return {
- "type": "recommendation",
- "source_id": None,
- "created_from": f"Recommended based on: {recommendation_source}",
- "metadata": {"recommendation_type": recommendation_type},
- }
-
- def test_source_type_recommendation(self):
- source = self._build_source_from_recommendation("user interests")
- assert source["type"] == "recommendation"
-
- def test_created_from_format(self):
- source = self._build_source_from_recommendation("trending topics")
- assert source["created_from"] == "Recommended based on: trending topics"
-
- def test_default_recommendation_type(self):
- source = self._build_source_from_recommendation("interests")
- assert source["metadata"]["recommendation_type"] == "topic_based"
-
- def test_custom_recommendation_type(self):
- source = self._build_source_from_recommendation(
- "interests", recommendation_type="collaborative"
- )
- assert source["metadata"]["recommendation_type"] == "collaborative"
-
-
-# --- Subscription type identifier ---
-
-
-class TestSubscriptionTypeIdentifier:
- """Tests for get_subscription_type method."""
-
- def test_returns_search_subscription(self):
- subscription_type = "search_subscription"
- assert subscription_type == "search_subscription"
-
- def test_subscription_type_attribute(self):
- # The subscription_type attribute (not the method)
- attr_type = "search"
- assert attr_type == "search"
-
-
-# --- Default refresh interval ---
-
-
-class TestDefaultRefreshInterval:
- """Tests for default refresh interval."""
-
- def test_default_6_hours(self):
- default_interval = 360 # minutes
- assert default_interval == 360
-
- def test_in_minutes(self):
- interval = 360
- assert interval / 60 == 6 # 6 hours
-
-
-# --- Query history management ---
-
-
-class TestQueryHistoryManagement:
- """Tests for query history list management."""
-
- def test_initial_history(self):
- query = "AI news"
- history = [query]
- assert len(history) == 1
- assert history[0] == query
-
- def test_append_evolved_query(self):
- history = ["AI news"]
- history.append("AI news GPT-4")
- assert len(history) == 2
- assert history[-1] == "AI news GPT-4"
-
- def test_preserves_original(self):
- history = ["original"]
- history.append("evolved1")
- history.append("evolved2")
- assert history[0] == "original"
-
-
-# --- Transform flag handling ---
-
-
-class TestTransformFlagHandling:
- """Tests for transform_to_news_query flag."""
-
- def _generate_query(self, base_query, transform_enabled):
- if transform_enabled:
- return f"{base_query} latest news developments"
- return base_query
-
- def test_transform_enabled(self):
- result = self._generate_query("AI", True)
- assert "latest news developments" in result
-
- def test_transform_disabled(self):
- result = self._generate_query("AI", False)
- assert result == "AI"
diff --git a/tests/news/test_security_patterns_behavior.py b/tests/news/test_security_patterns_behavior.py
deleted file mode 100644
index e72c348915..0000000000
--- a/tests/news/test_security_patterns_behavior.py
+++ /dev/null
@@ -1,941 +0,0 @@
-"""
-Behavioral tests for security patterns.
-
-These tests verify the logic of security patterns like authentication,
-authorization, input sanitization, token management, and access control
-without making actual system calls.
-"""
-
-import base64
-import hashlib
-import hmac
-import re
-import secrets
-import time
-from datetime import datetime, timedelta
-
-
-class TestPasswordHashing:
- """Tests for password hashing patterns."""
-
- def test_hash_password(self):
- """Test password hashing with salt."""
-
- def hash_password(password, salt=None):
- if salt is None:
- salt = secrets.token_hex(16)
- combined = f"{salt}{password}"
- hashed = hashlib.sha256(combined.encode()).hexdigest()
- return f"{salt}${hashed}"
-
- result = hash_password("mypassword")
- parts = result.split("$")
- assert len(parts) == 2
- assert len(parts[0]) == 32 # Salt is 16 bytes = 32 hex chars
- assert len(parts[1]) == 64 # SHA256 = 64 hex chars
-
- def test_verify_password(self):
- """Test password verification."""
-
- def hash_password(password, salt=None):
- if salt is None:
- salt = secrets.token_hex(16)
- combined = f"{salt}{password}"
- hashed = hashlib.sha256(combined.encode()).hexdigest()
- return f"{salt}${hashed}"
-
- def verify_password(password, stored_hash):
- salt = stored_hash.split("$")[0]
- return hash_password(password, salt) == stored_hash
-
- stored = hash_password("correctpassword")
- assert verify_password("correctpassword", stored) is True
- assert verify_password("wrongpassword", stored) is False
-
- def test_password_strength_check(self):
- """Test password strength validation."""
-
- def check_password_strength(password):
- score = 0
- if len(password) >= 8:
- score += 1
- if len(password) >= 12:
- score += 1
- if re.search(r"[A-Z]", password):
- score += 1
- if re.search(r"[a-z]", password):
- score += 1
- if re.search(r"\d", password):
- score += 1
- if re.search(r"[!@#$%^&*(),.?\":{}|<>]", password):
- score += 1
- return {
- "score": score,
- "strength": (
- "weak" if score < 3 else "medium" if score < 5 else "strong"
- ),
- }
-
- assert check_password_strength("abc")["strength"] == "weak"
- assert check_password_strength("abcd1234")["strength"] == "medium"
- assert check_password_strength("Abcd1234!@#")["strength"] == "strong"
-
- def test_common_password_check(self):
- """Test common password detection."""
-
- def is_common_password(password):
- common = {
- "password",
- "123456",
- "qwerty",
- "abc123",
- "letmein",
- "welcome",
- "admin",
- "password1",
- }
- return password.lower() in common
-
- assert is_common_password("password") is True
- assert is_common_password("123456") is True
- assert is_common_password("xK9#mNp2$vL") is False
-
- def test_password_similarity_check(self):
- """Test password similarity to username/email."""
-
- def is_too_similar(password, username, email=None):
- password_lower = password.lower()
- if username.lower() in password_lower:
- return True
- if email:
- email_local = email.split("@")[0].lower()
- if email_local in password_lower:
- return True
- return False
-
- assert is_too_similar("john123", "john") is True
- assert (
- is_too_similar("johndoe@pass", "john", "[email protected]")
- is True
- )
- assert (
- is_too_similar("secure#Pass1", "john", "[email protected]")
- is False
- )
-
-
-class TestTokenGeneration:
- """Tests for token generation patterns."""
-
- def test_generate_random_token(self):
- """Test random token generation."""
-
- def generate_token(length=32):
- return secrets.token_hex(length // 2)
-
- token = generate_token(32)
- assert len(token) == 32
- assert all(c in "0123456789abcdef" for c in token)
-
- def test_generate_url_safe_token(self):
- """Test URL-safe token generation."""
-
- def generate_url_safe_token(length=32):
- return secrets.token_urlsafe(length)
-
- token = generate_url_safe_token(32)
- # URL-safe base64 uses these characters
- assert all(
- c
- in "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
- for c in token
- )
-
- def test_token_uniqueness(self):
- """Test that generated tokens are unique."""
-
- def generate_token():
- return secrets.token_hex(16)
-
- tokens = {generate_token() for _ in range(100)}
- assert len(tokens) == 100 # All should be unique
-
- def test_token_expiry_encoding(self):
- """Test encoding expiry time in token."""
-
- def create_timed_token(data, expires_in_seconds):
- expires_at = int(time.time()) + expires_in_seconds
- token_data = f"{data}|{expires_at}"
- return base64.urlsafe_b64encode(token_data.encode()).decode()
-
- def decode_timed_token(token):
- decoded = base64.urlsafe_b64decode(token.encode()).decode()
- data, expires_at = decoded.rsplit("|", 1)
- return data, int(expires_at)
-
- token = create_timed_token("user123", 3600)
- data, expires_at = decode_timed_token(token)
- assert data == "user123"
- assert expires_at > time.time()
-
- def test_signed_token(self):
- """Test creating a signed token."""
-
- def create_signed_token(data, secret):
- encoded = base64.urlsafe_b64encode(data.encode()).decode()
- signature = hmac.new(
- secret.encode(), encoded.encode(), hashlib.sha256
- ).hexdigest()
- return f"{encoded}.{signature}"
-
- def verify_signed_token(token, secret):
- try:
- encoded, signature = token.rsplit(".", 1)
- expected_sig = hmac.new(
- secret.encode(), encoded.encode(), hashlib.sha256
- ).hexdigest()
- if not hmac.compare_digest(signature, expected_sig):
- return None
- return base64.urlsafe_b64decode(encoded.encode()).decode()
- except Exception:
- return None
-
- token = create_signed_token("user123", "secret")
- assert verify_signed_token(token, "secret") == "user123"
- assert verify_signed_token(token, "wrong_secret") is None
- assert verify_signed_token("tampered", "secret") is None
-
-
-class TestAccessControl:
- """Tests for access control patterns."""
-
- def test_role_based_access(self):
- """Test role-based access control."""
-
- def has_permission(user_roles, required_role):
- role_hierarchy = {
- "admin": 100,
- "moderator": 50,
- "editor": 30,
- "viewer": 10,
- }
- user_level = max(role_hierarchy.get(r, 0) for r in user_roles)
- required_level = role_hierarchy.get(required_role, 0)
- return user_level >= required_level
-
- assert has_permission(["admin"], "viewer") is True
- assert has_permission(["editor"], "moderator") is False
- assert has_permission(["moderator", "editor"], "editor") is True
-
- def test_permission_based_access(self):
- """Test permission-based access control."""
-
- def has_permission(user_permissions, required_permissions):
- return all(p in user_permissions for p in required_permissions)
-
- user_perms = {"read", "write", "delete"}
- assert has_permission(user_perms, ["read"]) is True
- assert has_permission(user_perms, ["read", "write"]) is True
- assert has_permission(user_perms, ["admin"]) is False
-
- def test_resource_ownership_check(self):
- """Test resource ownership check."""
-
- def can_access_resource(user_id, resource, is_admin=False):
- if is_admin:
- return True
- if resource.get("owner_id") == user_id:
- return True
- if user_id in resource.get("shared_with", []):
- return True
- if resource.get("is_public"):
- return True
- return False
-
- resource = {"owner_id": "user1", "shared_with": ["user2"]}
- assert can_access_resource("user1", resource) is True # Owner
- assert can_access_resource("user2", resource) is True # Shared
- assert can_access_resource("user3", resource) is False # No access
- assert can_access_resource("user3", resource, is_admin=True) is True
-
- def test_scope_based_access(self):
- """Test OAuth-style scope-based access."""
-
- def has_scope(token_scopes, required_scope):
- # Check for exact match or wildcard
- if required_scope in token_scopes:
- return True
- # Check for wildcard scopes (e.g., "user:*" matches "user:read")
- scope_parts = required_scope.split(":")
- if len(scope_parts) >= 2:
- wildcard = f"{scope_parts[0]}:*"
- if wildcard in token_scopes:
- return True
- return False
-
- scopes = {"user:read", "posts:*"}
- assert has_scope(scopes, "user:read") is True
- assert has_scope(scopes, "user:write") is False
- assert has_scope(scopes, "posts:read") is True # Wildcard match
- assert has_scope(scopes, "posts:write") is True # Wildcard match
-
- def test_time_based_access(self):
- """Test time-based access control."""
-
- def is_access_allowed(access_window, current_time=None):
- if current_time is None:
- current_time = datetime.now()
- if (
- access_window.get("start")
- and current_time < access_window["start"]
- ):
- return False
- if access_window.get("end") and current_time > access_window["end"]:
- return False
- return True
-
- now = datetime.now()
- # Valid window
- window1 = {
- "start": now - timedelta(hours=1),
- "end": now + timedelta(hours=1),
- }
- assert is_access_allowed(window1, now) is True
-
- # Expired window
- window2 = {
- "start": now - timedelta(hours=2),
- "end": now - timedelta(hours=1),
- }
- assert is_access_allowed(window2, now) is False
-
-
-class TestInputSanitization:
- """Tests for input sanitization patterns."""
-
- def test_sanitize_html(self):
- """Test HTML sanitization."""
-
- def sanitize_html(text):
- # Remove script tags
- text = re.sub(
- r"<script[^>]*>.*?</script>",
- "",
- text,
- flags=re.DOTALL | re.IGNORECASE,
- )
- # Remove event handlers
- text = re.sub(
- r"\s*on\w+\s*=\s*[\"'][^\"']*[\"']",
- "",
- text,
- flags=re.IGNORECASE,
- )
- # Remove javascript: URLs
- text = re.sub(r"javascript:", "", text, flags=re.IGNORECASE)
- return text
-
- assert sanitize_html("<script>alert('xss')</script>") == ""
- assert (
- sanitize_html('<a onclick="alert(1)">click</a>') == "<a>click</a>"
- )
- assert (
- sanitize_html('<a href="javascript:alert(1)">')
- == '<a href="alert(1)">'
- )
-
- def test_sanitize_sql_input(self):
- """Test SQL input sanitization."""
-
- def sanitize_sql_string(value):
- # Escape single quotes by doubling them
- return value.replace("'", "''")
-
- assert sanitize_sql_string("O'Brien") == "O''Brien"
- assert sanitize_sql_string("normal") == "normal"
- assert (
- sanitize_sql_string("'; DROP TABLE users; --")
- == "''; DROP TABLE users; --"
- )
-
- def test_sanitize_filename(self):
- """Test filename sanitization."""
-
- def sanitize_filename(filename):
- # Remove path separators
- filename = filename.replace("/", "_").replace("\\", "_")
- # Remove null bytes
- filename = filename.replace("\x00", "")
- # Remove other dangerous characters
- filename = re.sub(r"[<>:\"|?*]", "", filename)
- # Limit length
- if len(filename) > 255:
- name, ext = (
- filename.rsplit(".", 1)
- if "." in filename
- else (filename, "")
- )
- filename = (
- name[: 255 - len(ext) - 1] + "." + ext
- if ext
- else name[:255]
- )
- return filename
-
- assert sanitize_filename("../../../etc/passwd") == ".._.._.._etc_passwd"
- assert sanitize_filename("file<script>.txt") == "filescript.txt"
- assert sanitize_filename("normal_file.txt") == "normal_file.txt"
- assert sanitize_filename("/etc/passwd") == "_etc_passwd"
-
- def test_sanitize_url(self):
- """Test URL sanitization."""
-
- def sanitize_url(url):
- # Only allow http and https
- if not url.startswith(("http://", "https://")):
- return None
- # Block javascript protocol
- if "javascript:" in url.lower():
- return None
- # Block data URLs
- if url.lower().startswith("data:"):
- return None
- return url
-
- assert sanitize_url("https://example.com") == "https://example.com"
- assert sanitize_url("javascript:alert(1)") is None
- assert sanitize_url("data:text/html,<script>alert(1)</script>") is None
-
- def test_sanitize_email(self):
- """Test email sanitization."""
-
- def sanitize_email(email):
- # Lowercase
- email = email.lower().strip()
- # Remove potentially dangerous characters
- email = re.sub(r"[<>'\";]", "", email)
- # Validate basic format
- if not re.match(
- r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$", email
- ):
- return None
- return email
-
- assert sanitize_email("[email protected]") == "[email protected]"
- # After removing <>, becomes [email protected] which is valid
- assert (
- sanitize_email("user<script>@example.com")
- )
- # Invalid characters remain after sanitization
- assert (
- sanitize_email("user@exam ple.com") is None
- ) # Space makes it invalid
-
-
-class TestSessionManagement:
- """Tests for session management patterns."""
-
- def test_create_session(self):
- """Test session creation."""
-
- def create_session(user_id, expires_in=3600):
- return {
- "session_id": secrets.token_hex(32),
- "user_id": user_id,
- "created_at": time.time(),
- "expires_at": time.time() + expires_in,
- "is_active": True,
- }
-
- session = create_session("user123")
- assert len(session["session_id"]) == 64
- assert session["user_id"] == "user123"
- assert session["is_active"] is True
- assert session["expires_at"] > session["created_at"]
-
- def test_validate_session(self):
- """Test session validation."""
-
- def validate_session(session):
- if not session:
- return False
- if not session.get("is_active"):
- return False
- if time.time() > session.get("expires_at", 0):
- return False
- return True
-
- valid_session = {
- "session_id": "abc",
- "is_active": True,
- "expires_at": time.time() + 3600,
- }
- expired_session = {
- "session_id": "abc",
- "is_active": True,
- "expires_at": time.time() - 100,
- }
- inactive_session = {
- "session_id": "abc",
- "is_active": False,
- "expires_at": time.time() + 3600,
- }
-
- assert validate_session(valid_session) is True
- assert validate_session(expired_session) is False
- assert validate_session(inactive_session) is False
- assert validate_session(None) is False
-
- def test_refresh_session(self):
- """Test session refresh."""
-
- def refresh_session(session, extension=3600):
- if not session or not session.get("is_active"):
- return None
- return {
- **session,
- "expires_at": time.time() + extension,
- "refreshed_at": time.time(),
- }
-
- session = {
- "session_id": "abc",
- "is_active": True,
- "expires_at": time.time() + 100,
- }
- refreshed = refresh_session(session)
- assert refreshed["expires_at"] > session["expires_at"]
- assert "refreshed_at" in refreshed
-
- def test_session_fixation_prevention(self):
- """Test session fixation prevention by regenerating ID."""
-
- def regenerate_session_id(session):
- return {
- **session,
- "session_id": secrets.token_hex(32),
- "regenerated_at": time.time(),
- }
-
- session = {"session_id": "old_id", "user_id": "user123"}
- new_session = regenerate_session_id(session)
- assert new_session["session_id"] != "old_id"
- assert new_session["user_id"] == "user123"
-
- def test_concurrent_session_limit(self):
- """Test limiting concurrent sessions."""
-
- def get_sessions_to_invalidate(sessions, max_sessions=5):
- if len(sessions) <= max_sessions:
- return []
- # Sort by created_at, invalidate oldest
- sorted_sessions = sorted(sessions, key=lambda s: s["created_at"])
- return sorted_sessions[: len(sessions) - max_sessions]
-
- sessions = [{"session_id": f"s{i}", "created_at": i} for i in range(7)]
- to_invalidate = get_sessions_to_invalidate(sessions, max_sessions=5)
- assert len(to_invalidate) == 2
- assert to_invalidate[0]["session_id"] == "s0"
- assert to_invalidate[1]["session_id"] == "s1"
-
-
-class TestRateLimiting:
- """Tests for rate limiting security patterns."""
-
- def test_login_attempt_tracking(self):
- """Test tracking login attempts."""
-
- class LoginAttemptTracker:
- def __init__(self, max_attempts=5, lockout_duration=300):
- self.attempts = {}
- self.max_attempts = max_attempts
- self.lockout_duration = lockout_duration
-
- def record_attempt(self, identifier, success=False):
- now = time.time()
- if identifier not in self.attempts:
- self.attempts[identifier] = {
- "count": 0,
- "first_attempt": now,
- "locked_until": 0,
- }
-
- data = self.attempts[identifier]
- if success:
- data["count"] = 0
- return True
-
- data["count"] += 1
- if data["count"] >= self.max_attempts:
- data["locked_until"] = now + self.lockout_duration
- return True
-
- def is_locked(self, identifier):
- data = self.attempts.get(identifier)
- if not data:
- return False
- return time.time() < data.get("locked_until", 0)
-
- tracker = LoginAttemptTracker(max_attempts=3)
- tracker.record_attempt("user1", success=False)
- tracker.record_attempt("user1", success=False)
- assert tracker.is_locked("user1") is False
- tracker.record_attempt("user1", success=False)
- assert tracker.is_locked("user1") is True
-
- def test_progressive_delay(self):
- """Test progressive delay for failed attempts."""
-
- def calculate_delay(attempt_count, base_delay=1, max_delay=60):
- delay = base_delay * (2 ** (attempt_count - 1))
- return min(delay, max_delay)
-
- assert calculate_delay(1) == 1
- assert calculate_delay(2) == 2
- assert calculate_delay(3) == 4
- assert calculate_delay(10) == 60 # Capped at max
-
- def test_ip_based_blocking(self):
- """Test IP-based blocking."""
-
- class IPBlocker:
- def __init__(self):
- self.blocked_ips = {}
-
- def block(self, ip, duration=3600, reason=""):
- self.blocked_ips[ip] = {
- "blocked_at": time.time(),
- "expires_at": time.time() + duration,
- "reason": reason,
- }
-
- def is_blocked(self, ip):
- if ip not in self.blocked_ips:
- return False
- return time.time() < self.blocked_ips[ip]["expires_at"]
-
- blocker = IPBlocker()
- blocker.block(
- "192.168.1.1", duration=3600, reason="Too many failed logins"
- )
- assert blocker.is_blocked("192.168.1.1") is True
- assert blocker.is_blocked("192.168.1.2") is False
-
-
-class TestCSRFProtection:
- """Tests for CSRF protection patterns."""
-
- def test_generate_csrf_token(self):
- """Test CSRF token generation."""
-
- def generate_csrf_token(session_id, secret):
- message = f"{session_id}|{int(time.time())}"
- signature = hmac.new(
- secret.encode(), message.encode(), hashlib.sha256
- ).hexdigest()
- token_data = f"{message}|{signature}"
- return base64.urlsafe_b64encode(token_data.encode()).decode()
-
- token = generate_csrf_token("session123", "secret")
- assert len(token) > 0
-
- def test_validate_csrf_token(self):
- """Test CSRF token validation."""
-
- def generate_csrf_token(session_id, secret):
- timestamp = int(time.time())
- message = f"{session_id}|{timestamp}"
- signature = hmac.new(
- secret.encode(), message.encode(), hashlib.sha256
- ).hexdigest()
- token_data = f"{message}|{signature}"
- return base64.urlsafe_b64encode(token_data.encode()).decode()
-
- def validate_csrf_token(token, session_id, secret, max_age=3600):
- try:
- decoded = base64.urlsafe_b64decode(token.encode()).decode()
- parts = decoded.split("|")
- if len(parts) != 3:
- return False
- token_session, timestamp, signature = parts
- if token_session != session_id:
- return False
- if int(time.time()) - int(timestamp) > max_age:
- return False
- message = f"{token_session}|{timestamp}"
- expected_sig = hmac.new(
- secret.encode(), message.encode(), hashlib.sha256
- ).hexdigest()
- return hmac.compare_digest(signature, expected_sig)
- except Exception:
- return False
-
- secret = "my_secret"
- token = generate_csrf_token("session123", secret)
- assert validate_csrf_token(token, "session123", secret) is True
- assert validate_csrf_token(token, "other_session", secret) is False
- assert validate_csrf_token("invalid", "session123", secret) is False
-
- def test_double_submit_cookie_validation(self):
- """Test double submit cookie validation."""
-
- def validate_double_submit(cookie_token, header_token):
- if not cookie_token or not header_token:
- return False
- return hmac.compare_digest(cookie_token, header_token)
-
- assert validate_double_submit("token123", "token123") is True
- assert validate_double_submit("token123", "token456") is False
- assert validate_double_submit("", "token123") is False
-
-
-class TestEncryption:
- """Tests for encryption utility patterns."""
-
- def test_derive_key_from_password(self):
- """Test key derivation from password."""
-
- def derive_key(password, salt, iterations=100000):
- # Simple PBKDF2-like derivation
- key = password.encode()
- salt_bytes = salt.encode()
- for _ in range(iterations):
- key = hashlib.sha256(key + salt_bytes).digest()
- return key.hex()
-
- key1 = derive_key("password", "salt1", iterations=1000)
- key2 = derive_key("password", "salt1", iterations=1000)
- key3 = derive_key("password", "salt2", iterations=1000)
-
- assert key1 == key2 # Same input = same key
- assert key1 != key3 # Different salt = different key
-
- def test_create_secure_hash(self):
- """Test creating secure hash."""
-
- def secure_hash(data, algorithm="sha256"):
- if algorithm == "sha256":
- return hashlib.sha256(data.encode()).hexdigest()
- if algorithm == "sha512":
- return hashlib.sha512(data.encode()).hexdigest()
- return ""
-
- hash256 = secure_hash("test", "sha256")
- hash512 = secure_hash("test", "sha512")
- assert len(hash256) == 64
- assert len(hash512) == 128
-
- def test_constant_time_compare(self):
- """Test constant-time string comparison."""
-
- def secure_compare(a, b):
- return hmac.compare_digest(a, b)
-
- assert secure_compare("secret", "secret") is True
- assert secure_compare("secret", "other") is False
-
- def test_mask_sensitive_data(self):
- """Test masking sensitive data for logs."""
-
- def mask_sensitive(data, visible_chars=4):
- if not data or len(data) <= visible_chars:
- return "*" * len(data) if data else ""
- return data[:visible_chars] + "*" * (len(data) - visible_chars)
-
- assert mask_sensitive("1234567890123456") == "1234************"
- assert mask_sensitive("abc") == "***"
- assert mask_sensitive("") == ""
-
- def test_generate_recovery_codes(self):
- """Test generating account recovery codes."""
-
- def generate_recovery_codes(count=10, length=8):
- codes = []
- for _ in range(count):
- code = secrets.token_hex(length // 2).upper()
- # Format as XXXX-XXXX
- formatted = f"{code[:4]}-{code[4:]}"
- codes.append(formatted)
- return codes
-
- codes = generate_recovery_codes(10)
- assert len(codes) == 10
- assert all("-" in code for code in codes)
- assert len(set(codes)) == 10 # All unique
-
-
-class TestAPIKeySecurity:
- """Tests for API key security patterns."""
-
- def test_generate_api_key(self):
- """Test API key generation."""
-
- def generate_api_key(prefix="sk"):
- key = secrets.token_urlsafe(32)
- return f"{prefix}_{key}"
-
- key = generate_api_key("sk")
- assert key.startswith("sk_")
- assert len(key) > 35
-
- def test_hash_api_key(self):
- """Test API key hashing for storage."""
-
- def hash_api_key(key):
- return hashlib.sha256(key.encode()).hexdigest()
-
- key = "sk_abcdef123456"
- hashed = hash_api_key(key)
- assert len(hashed) == 64
- assert hashed != key
-
- def test_validate_api_key_format(self):
- """Test API key format validation."""
-
- def validate_api_key_format(key, expected_prefix="sk"):
- if not key:
- return False
- if not key.startswith(f"{expected_prefix}_"):
- return False
- # Check minimum length
- if len(key) < 20:
- return False
- return True
-
- assert validate_api_key_format("sk_abcdef123456789012345") is True
- assert validate_api_key_format("pk_abcdef123456789012345") is False
- assert validate_api_key_format("sk_short") is False
- assert validate_api_key_format("") is False
-
- def test_api_key_rotation_check(self):
- """Test checking if API key needs rotation."""
-
- def should_rotate_key(key_metadata, max_age_days=90):
- created_at = key_metadata.get("created_at")
- if not created_at:
- return True
- age_days = (time.time() - created_at) / (24 * 3600)
- return age_days > max_age_days
-
- # Old key - should rotate
- old_key = {"created_at": time.time() - (100 * 24 * 3600)}
- assert should_rotate_key(old_key) is True
-
- # New key - no rotation needed
- new_key = {"created_at": time.time()}
- assert should_rotate_key(new_key) is False
-
- def test_api_key_scoping(self):
- """Test API key scope validation."""
-
- def validate_key_scope(key_scopes, required_scope):
- if "*" in key_scopes:
- return True
- return required_scope in key_scopes
-
- key_scopes = {"read", "write"}
- assert validate_key_scope(key_scopes, "read") is True
- assert validate_key_scope(key_scopes, "delete") is False
- assert validate_key_scope({"*"}, "anything") is True
-
-
-class TestAuditLogging:
- """Tests for security audit logging patterns."""
-
- def test_create_audit_entry(self):
- """Test creating audit log entry."""
-
- def create_audit_entry(action, user_id, resource, details=None):
- return {
- "timestamp": time.time(),
- "action": action,
- "user_id": user_id,
- "resource": resource,
- "details": details or {},
- "ip_address": None, # Would be set from request
- }
-
- entry = create_audit_entry(
- "login", "user123", "auth", {"success": True}
- )
- assert entry["action"] == "login"
- assert entry["user_id"] == "user123"
- assert entry["details"]["success"] is True
-
- def test_redact_sensitive_fields(self):
- """Test redacting sensitive fields in audit logs."""
-
- def redact_sensitive(data, sensitive_fields=None):
- if sensitive_fields is None:
- sensitive_fields = {"password", "token", "api_key", "secret"}
- result = {}
- for key, value in data.items():
- if key.lower() in sensitive_fields:
- result[key] = "[REDACTED]"
- elif isinstance(value, dict):
- result[key] = redact_sensitive(value, sensitive_fields)
- else:
- result[key] = value
- return result
-
- data = {
- "username": "john",
- "password": "secret123",
- "nested": {"api_key": "abc123"},
- }
- redacted = redact_sensitive(data)
- assert redacted["username"] == "john"
- assert redacted["password"] == "[REDACTED]"
- assert redacted["nested"]["api_key"] == "[REDACTED]"
-
- def test_classify_security_event(self):
- """Test classifying security events by severity."""
-
- def classify_event(event_type):
- critical = {"breach", "data_leak", "privilege_escalation"}
- high = {
- "failed_login_threshold",
- "api_key_compromised",
- "admin_action",
- }
- medium = {"password_reset", "permission_change", "session_expired"}
- low = {"login", "logout", "settings_change"}
-
- if event_type in critical:
- return "critical"
- if event_type in high:
- return "high"
- if event_type in medium:
- return "medium"
- if event_type in low:
- return "low"
- return "info"
-
- assert classify_event("breach") == "critical"
- assert classify_event("failed_login_threshold") == "high"
- assert classify_event("password_reset") == "medium"
- assert classify_event("login") == "low"
-
- def test_format_audit_log(self):
- """Test formatting audit log for storage."""
-
- def format_audit_log(entry):
- return (
- f"[{entry['timestamp']}] "
- f"{entry['action'].upper()} "
- f"user={entry['user_id']} "
- f"resource={entry['resource']} "
- f"details={entry['details']}"
- )
-
- entry = {
- "timestamp": 1704067200,
- "action": "login",
- "user_id": "user123",
- "resource": "auth",
- "details": {"success": True},
- }
- log = format_audit_log(entry)
- assert "LOGIN" in log
- assert "user=user123" in log
diff --git a/tests/news/test_state_machine_patterns_behavior.py b/tests/news/test_state_machine_patterns_behavior.py
deleted file mode 100644
index 930ebff4ac..0000000000
--- a/tests/news/test_state_machine_patterns_behavior.py
+++ /dev/null
@@ -1,597 +0,0 @@
-"""
-Deep behavioral tests for state machine patterns.
-Tests state transitions, guards, actions,
-and workflow state management logic.
-"""
-
-from datetime import datetime, timezone
-
-
-# --- Basic state machine patterns ---
-
-
-class TestBasicStateMachine:
- """Tests for basic state machine patterns."""
-
- def _create_state_machine(self, initial_state, transitions):
- """Create a simple state machine."""
- return {
- "current_state": initial_state,
- "transitions": transitions,
- "history": [initial_state],
- }
-
- def _can_transition(self, machine, event):
- """Check if transition is allowed."""
- current = machine["current_state"]
- transitions = machine["transitions"]
- if current not in transitions:
- return False
- return event in transitions[current]
-
- def _transition(self, machine, event):
- """Perform state transition."""
- if not self._can_transition(machine, event):
- return False
- current = machine["current_state"]
- new_state = machine["transitions"][current][event]
- machine["current_state"] = new_state
- machine["history"].append(new_state)
- return True
-
- def test_initial_state(self):
- machine = self._create_state_machine("idle", {})
- assert machine["current_state"] == "idle"
-
- def test_can_transition(self):
- transitions = {"idle": {"start": "running"}}
- machine = self._create_state_machine("idle", transitions)
- assert self._can_transition(machine, "start") is True
-
- def test_cannot_transition_invalid_event(self):
- transitions = {"idle": {"start": "running"}}
- machine = self._create_state_machine("idle", transitions)
- assert self._can_transition(machine, "stop") is False
-
- def test_transition_changes_state(self):
- transitions = {"idle": {"start": "running"}}
- machine = self._create_state_machine("idle", transitions)
- self._transition(machine, "start")
- assert machine["current_state"] == "running"
-
- def test_history_tracks_states(self):
- transitions = {
- "idle": {"start": "running"},
- "running": {"stop": "stopped"},
- }
- machine = self._create_state_machine("idle", transitions)
- self._transition(machine, "start")
- self._transition(machine, "stop")
- assert machine["history"] == ["idle", "running", "stopped"]
-
-
-# --- Subscription state patterns ---
-
-
-class TestSubscriptionStates:
- """Tests for subscription state patterns."""
-
- def _get_subscription_transitions(self):
- """Get subscription state transitions."""
- return {
- "pending": {"activate": "active", "cancel": "cancelled"},
- "active": {
- "pause": "paused",
- "cancel": "cancelled",
- "expire": "expired",
- },
- "paused": {"resume": "active", "cancel": "cancelled"},
- "expired": {"renew": "active"},
- "cancelled": {}, # Terminal state
- }
-
- def _is_terminal_state(self, state):
- """Check if state is terminal."""
- transitions = self._get_subscription_transitions()
- return state not in transitions or len(transitions.get(state, {})) == 0
-
- def _get_available_actions(self, state):
- """Get available actions for state."""
- transitions = self._get_subscription_transitions()
- return list(transitions.get(state, {}).keys())
-
- def test_pending_can_activate(self):
- actions = self._get_available_actions("pending")
- assert "activate" in actions
-
- def test_active_can_pause(self):
- actions = self._get_available_actions("active")
- assert "pause" in actions
-
- def test_cancelled_is_terminal(self):
- assert self._is_terminal_state("cancelled") is True
-
- def test_active_not_terminal(self):
- assert self._is_terminal_state("active") is False
-
-
-# --- Card state patterns ---
-
-
-class TestCardStates:
- """Tests for news card state patterns."""
-
- def _get_card_transitions(self):
- """Get card state transitions."""
- return {
- "draft": {"publish": "published", "archive": "archived"},
- "published": {"archive": "archived", "feature": "featured"},
- "featured": {"unfeature": "published", "archive": "archived"},
- "archived": {"restore": "published"},
- }
-
- def _validate_card_state(self, state):
- """Validate card state."""
- valid_states = ["draft", "published", "featured", "archived"]
- return state in valid_states
-
- def test_draft_can_publish(self):
- transitions = self._get_card_transitions()
- assert "publish" in transitions["draft"]
-
- def test_published_can_feature(self):
- transitions = self._get_card_transitions()
- assert "feature" in transitions["published"]
-
- def test_valid_state(self):
- assert self._validate_card_state("published") is True
-
- def test_invalid_state(self):
- assert self._validate_card_state("unknown") is False
-
-
-# --- Research state patterns ---
-
-
-class TestResearchStates:
- """Tests for research task state patterns."""
-
- def _get_research_transitions(self):
- """Get research state transitions."""
- return {
- "queued": {"start": "running", "cancel": "cancelled"},
- "running": {
- "complete": "completed",
- "fail": "failed",
- "cancel": "cancelled",
- },
- "completed": {"archive": "archived"},
- "failed": {"retry": "queued", "archive": "archived"},
- "cancelled": {"archive": "archived"},
- "archived": {},
- }
-
- def _can_retry(self, state):
- """Check if research can be retried."""
- return state == "failed"
-
- def _is_active(self, state):
- """Check if research is active."""
- return state in ["queued", "running"]
-
- def _is_finished(self, state):
- """Check if research is finished."""
- return state in ["completed", "failed", "cancelled", "archived"]
-
- def test_failed_can_retry(self):
- assert self._can_retry("failed") is True
-
- def test_completed_cannot_retry(self):
- assert self._can_retry("completed") is False
-
- def test_running_is_active(self):
- assert self._is_active("running") is True
-
- def test_completed_is_finished(self):
- assert self._is_finished("completed") is True
-
- def test_running_not_finished(self):
- assert self._is_finished("running") is False
-
-
-# --- Guard condition patterns ---
-
-
-class TestGuardConditions:
- """Tests for state transition guard conditions."""
-
- def _check_guard(self, guard_name, context):
- """Check if guard condition passes."""
- guards = {
- "is_authenticated": lambda ctx: ctx.get("user_id") is not None,
- "has_permission": lambda ctx: (
- ctx.get("role") in ["admin", "editor"]
- ),
- "is_valid": lambda ctx: ctx.get("is_valid", False),
- "not_expired": lambda ctx: (
- ctx.get("expires_at", datetime.max) > datetime.now(timezone.utc)
- ),
- }
- guard_func = guards.get(guard_name)
- if not guard_func:
- return True
- return guard_func(context)
-
- def _transition_with_guard(self, machine, event, guard, context):
- """Transition only if guard passes."""
- if not self._check_guard(guard, context):
- return False, "Guard failed"
- # Perform transition logic would go here
- return True, "Success"
-
- def test_authenticated_guard_passes(self):
- context = {"user_id": "123"}
- assert self._check_guard("is_authenticated", context) is True
-
- def test_authenticated_guard_fails(self):
- context = {}
- assert self._check_guard("is_authenticated", context) is False
-
- def test_permission_guard_admin(self):
- context = {"role": "admin"}
- assert self._check_guard("has_permission", context) is True
-
- def test_permission_guard_user_fails(self):
- context = {"role": "user"}
- assert self._check_guard("has_permission", context) is False
-
-
-# --- Action patterns ---
-
-
-class TestStateActions:
- """Tests for state transition actions."""
-
- def _execute_entry_action(self, state, context):
- """Execute action when entering state."""
- actions = {
- "running": lambda ctx: ctx.update(
- {"started_at": datetime.now(timezone.utc)}
- ),
- "completed": lambda ctx: ctx.update(
- {"completed_at": datetime.now(timezone.utc)}
- ),
- "paused": lambda ctx: ctx.update(
- {"paused_at": datetime.now(timezone.utc)}
- ),
- }
- action = actions.get(state)
- if action:
- action(context)
- return context
-
- def _execute_exit_action(self, state, context):
- """Execute action when exiting state."""
- actions = {
- "running": lambda ctx: ctx.update(
- {"duration": self._calculate_duration(ctx)}
- ),
- }
- action = actions.get(state)
- if action:
- action(context)
- return context
-
- def _calculate_duration(self, context):
- """Calculate duration from started_at."""
- started = context.get("started_at")
- if started:
- return (datetime.now(timezone.utc) - started).total_seconds()
- return 0
-
- def test_entry_action_sets_timestamp(self):
- context = {}
- self._execute_entry_action("running", context)
- assert "started_at" in context
-
- def test_completed_entry_action(self):
- context = {}
- self._execute_entry_action("completed", context)
- assert "completed_at" in context
-
-
-# --- Workflow state patterns ---
-
-
-class TestWorkflowStates:
- """Tests for multi-step workflow states."""
-
- def _create_workflow(self, steps):
- """Create a workflow with steps."""
- return {
- "steps": steps,
- "current_step": 0,
- "completed_steps": [],
- "status": "pending",
- }
-
- def _advance_workflow(self, workflow):
- """Advance to next step."""
- if workflow["current_step"] >= len(workflow["steps"]):
- return False
- current = workflow["steps"][workflow["current_step"]]
- workflow["completed_steps"].append(current)
- workflow["current_step"] += 1
- if workflow["current_step"] >= len(workflow["steps"]):
- workflow["status"] = "completed"
- else:
- workflow["status"] = "in_progress"
- return True
-
- def _get_current_step(self, workflow):
- """Get current step name."""
- if workflow["current_step"] >= len(workflow["steps"]):
- return None
- return workflow["steps"][workflow["current_step"]]
-
- def _get_progress(self, workflow):
- """Get workflow progress percentage."""
- if not workflow["steps"]:
- return 100
- return (workflow["current_step"] / len(workflow["steps"])) * 100
-
- def test_workflow_starts_pending(self):
- workflow = self._create_workflow(["step1", "step2"])
- assert workflow["status"] == "pending"
-
- def test_advance_changes_step(self):
- workflow = self._create_workflow(["step1", "step2"])
- self._advance_workflow(workflow)
- assert workflow["current_step"] == 1
-
- def test_advance_completes_workflow(self):
- workflow = self._create_workflow(["step1"])
- self._advance_workflow(workflow)
- assert workflow["status"] == "completed"
-
- def test_progress_calculation(self):
- workflow = self._create_workflow(["a", "b", "c", "d"])
- self._advance_workflow(workflow)
- self._advance_workflow(workflow)
- assert self._get_progress(workflow) == 50
-
-
-# --- Hierarchical state patterns ---
-
-
-class TestHierarchicalStates:
- """Tests for hierarchical state machine patterns."""
-
- def _get_parent_state(self, state, hierarchy):
- """Get parent state from hierarchy."""
- for parent, children in hierarchy.items():
- if state in children:
- return parent
- return None
-
- def _get_child_states(self, parent, hierarchy):
- """Get child states of a parent."""
- return hierarchy.get(parent, [])
-
- def _is_in_state(self, current, target, hierarchy):
- """Check if current state is or is within target state."""
- if current == target:
- return True
- parent = self._get_parent_state(current, hierarchy)
- if parent:
- return self._is_in_state(parent, target, hierarchy)
- return False
-
- def test_get_parent_state(self):
- hierarchy = {"active": ["running", "paused"]}
- parent = self._get_parent_state("running", hierarchy)
- assert parent == "active"
-
- def test_get_child_states(self):
- hierarchy = {"active": ["running", "paused"]}
- children = self._get_child_states("active", hierarchy)
- assert "running" in children
-
- def test_is_in_nested_state(self):
- hierarchy = {"active": ["running", "paused"]}
- assert self._is_in_state("running", "active", hierarchy) is True
-
- def test_not_in_unrelated_state(self):
- hierarchy = {"active": ["running", "paused"]}
- assert self._is_in_state("running", "idle", hierarchy) is False
-
-
-# --- Parallel state patterns ---
-
-
-class TestParallelStates:
- """Tests for parallel/orthogonal state patterns."""
-
- def _create_parallel_machine(self, regions):
- """Create parallel state machine with multiple regions."""
- return {
- "regions": {
- name: {"state": initial} for name, initial in regions.items()
- },
- }
-
- def _get_region_state(self, machine, region):
- """Get state of a specific region."""
- return machine["regions"].get(region, {}).get("state")
-
- def _transition_region(self, machine, region, new_state):
- """Transition a specific region."""
- if region in machine["regions"]:
- machine["regions"][region]["state"] = new_state
- return True
- return False
-
- def _get_combined_state(self, machine):
- """Get combined state from all regions."""
- return {name: r["state"] for name, r in machine["regions"].items()}
-
- def test_parallel_initial_states(self):
- machine = self._create_parallel_machine(
- {"audio": "muted", "video": "off"}
- )
- assert self._get_region_state(machine, "audio") == "muted"
- assert self._get_region_state(machine, "video") == "off"
-
- def test_transition_single_region(self):
- machine = self._create_parallel_machine(
- {"audio": "muted", "video": "off"}
- )
- self._transition_region(machine, "audio", "playing")
- assert self._get_region_state(machine, "audio") == "playing"
- assert self._get_region_state(machine, "video") == "off"
-
- def test_combined_state(self):
- machine = self._create_parallel_machine({"a": "s1", "b": "s2"})
- combined = self._get_combined_state(machine)
- assert combined == {"a": "s1", "b": "s2"}
-
-
-# --- State persistence patterns ---
-
-
-class TestStatePersistence:
- """Tests for state persistence patterns."""
-
- def _serialize_state(self, machine):
- """Serialize state machine to dict."""
- return {
- "current_state": machine["current_state"],
- "history": machine.get("history", []),
- "context": machine.get("context", {}),
- }
-
- def _deserialize_state(self, data, transitions):
- """Deserialize state machine from dict."""
- return {
- "current_state": data["current_state"],
- "transitions": transitions,
- "history": data.get("history", [data["current_state"]]),
- "context": data.get("context", {}),
- }
-
- def test_serialize_preserves_state(self):
- machine = {
- "current_state": "running",
- "history": ["idle", "running"],
- "context": {"user": "test"},
- }
- serialized = self._serialize_state(machine)
- assert serialized["current_state"] == "running"
- assert serialized["history"] == ["idle", "running"]
-
- def test_deserialize_restores_state(self):
- data = {
- "current_state": "paused",
- "history": ["idle", "running", "paused"],
- }
- transitions = {"paused": {"resume": "running"}}
- machine = self._deserialize_state(data, transitions)
- assert machine["current_state"] == "paused"
- assert machine["transitions"] == transitions
-
-
-# --- State validation patterns ---
-
-
-class TestStateValidation:
- """Tests for state validation patterns."""
-
- def _validate_state(self, state, valid_states):
- """Validate state is in valid states."""
- return state in valid_states
-
- def _validate_transition(self, from_state, to_state, transitions):
- """Validate transition is allowed."""
- if from_state not in transitions:
- return False
- allowed = transitions[from_state].values()
- return to_state in allowed
-
- def _validate_machine(self, machine):
- """Validate state machine integrity."""
- errors = []
- current = machine.get("current_state")
- transitions = machine.get("transitions", {})
- # Check current state is valid
- all_states = set(transitions.keys())
- for targets in transitions.values():
- all_states.update(targets.values())
- if current not in all_states:
- errors.append(f"Invalid current state: {current}")
- return len(errors) == 0, errors
-
- def test_valid_state(self):
- assert (
- self._validate_state("active", ["idle", "active", "done"]) is True
- )
-
- def test_invalid_state(self):
- assert self._validate_state("unknown", ["idle", "active"]) is False
-
- def test_valid_transition(self):
- transitions = {"idle": {"start": "running"}}
- assert self._validate_transition("idle", "running", transitions) is True
-
- def test_invalid_transition(self):
- transitions = {"idle": {"start": "running"}}
- assert (
- self._validate_transition("idle", "stopped", transitions) is False
- )
-
-
-# --- State timeout patterns ---
-
-
-class TestStateTimeouts:
- """Tests for state timeout patterns."""
-
- def _check_timeout(self, entered_at, timeout_seconds):
- """Check if state has timed out."""
- if not entered_at:
- return False
- elapsed = (datetime.now(timezone.utc) - entered_at).total_seconds()
- return elapsed > timeout_seconds
-
- def _get_timeout_for_state(self, state):
- """Get timeout configuration for state."""
- timeouts = {
- "pending": 3600, # 1 hour
- "processing": 300, # 5 minutes
- "waiting": 86400, # 24 hours
- }
- return timeouts.get(state)
-
- def _should_auto_transition(self, state, entered_at):
- """Check if state should auto-transition due to timeout."""
- timeout = self._get_timeout_for_state(state)
- if not timeout:
- return False
- return self._check_timeout(entered_at, timeout)
-
- def test_no_timeout_fresh_state(self):
- entered = datetime.now(timezone.utc)
- assert self._check_timeout(entered, 60) is False
-
- def test_timeout_expired(self):
- from datetime import timedelta
-
- entered = datetime.now(timezone.utc) - timedelta(seconds=120)
- assert self._check_timeout(entered, 60) is True
-
- def test_state_has_timeout(self):
- timeout = self._get_timeout_for_state("pending")
- assert timeout == 3600
-
- def test_state_no_timeout(self):
- timeout = self._get_timeout_for_state("completed")
- assert timeout is None
diff --git a/tests/news/test_storage_interfaces_behavior.py b/tests/news/test_storage_interfaces_behavior.py
deleted file mode 100644
index a048b09cf2..0000000000
--- a/tests/news/test_storage_interfaces_behavior.py
+++ /dev/null
@@ -1,725 +0,0 @@
-"""
-Deep behavioral tests for storage interface contracts and patterns.
-Tests BaseStorage, CardStorage, SubscriptionStorage, RatingStorage,
-PreferenceStorage, SearchHistoryStorage, and NewsItemStorage interfaces.
-"""
-
-from datetime import datetime, timezone, timedelta
-import uuid
-
-
-# --- UUID generation ---
-
-
-class TestUUIDGeneration:
- """Tests for storage ID generation."""
-
- def test_generates_valid_uuid(self):
- new_id = str(uuid.uuid4())
- assert len(new_id) == 36
-
- def test_uuid_is_unique(self):
- id1 = str(uuid.uuid4())
- id2 = str(uuid.uuid4())
- assert id1 != id2
-
- def test_uuid_format(self):
- new_id = str(uuid.uuid4())
- parts = new_id.split("-")
- assert len(parts) == 5
- assert len(parts[0]) == 8
- assert len(parts[1]) == 4
- assert len(parts[2]) == 4
- assert len(parts[3]) == 4
- assert len(parts[4]) == 12
-
-
-# --- BaseStorage CRUD patterns ---
-
-
-class TestBaseStorageCRUDPatterns:
- """Tests for BaseStorage CRUD operation patterns."""
-
- def test_create_returns_string_id(self):
- """Create should return a string ID."""
- result = str(uuid.uuid4())
- assert isinstance(result, str)
- assert len(result) > 0
-
- def test_get_returns_none_for_missing(self):
- """Get should return None for missing records."""
- storage = {}
- result = storage.get("missing-id")
- assert result is None
-
- def test_get_returns_dict_for_existing(self):
- """Get should return dict for existing records."""
- storage = {"id-1": {"id": "id-1", "name": "test"}}
- result = storage.get("id-1")
- assert isinstance(result, dict)
- assert result["name"] == "test"
-
- def test_update_returns_bool(self):
- """Update should return success boolean."""
- storage = {"id-1": {"name": "old"}}
- storage["id-1"]["name"] = "new"
- success = True
- assert success is True
-
- def test_delete_returns_bool(self):
- """Delete should return success boolean."""
- storage = {"id-1": {}}
- del storage["id-1"]
- assert "id-1" not in storage
-
- def test_list_returns_list(self):
- """List should return a list."""
- storage = {"1": {}, "2": {}}
- result = list(storage.values())
- assert isinstance(result, list)
-
-
-# --- List with filters pattern ---
-
-
-class TestListFilterPattern:
- """Tests for list filtering pattern."""
-
- def _list_with_filters(self, items, filters=None, limit=100, offset=0):
- """Pattern for filtering and pagination."""
- result = items
- if filters:
- for key, value in filters.items():
- result = [i for i in result if i.get(key) == value]
- return result[offset : offset + limit]
-
- def test_no_filters(self):
- items = [{"id": "1"}, {"id": "2"}, {"id": "3"}]
- result = self._list_with_filters(items)
- assert len(result) == 3
-
- def test_filter_by_status(self):
- items = [
- {"id": "1", "status": "active"},
- {"id": "2", "status": "paused"},
- {"id": "3", "status": "active"},
- ]
- result = self._list_with_filters(items, {"status": "active"})
- assert len(result) == 2
-
- def test_filter_with_limit(self):
- items = [{"id": str(i)} for i in range(10)]
- result = self._list_with_filters(items, limit=5)
- assert len(result) == 5
-
- def test_filter_with_offset(self):
- items = [{"id": str(i)} for i in range(10)]
- result = self._list_with_filters(items, offset=5, limit=3)
- assert result[0]["id"] == "5"
- assert len(result) == 3
-
- def test_multiple_filters(self):
- items = [
- {"status": "active", "type": "search"},
- {"status": "active", "type": "topic"},
- {"status": "paused", "type": "search"},
- ]
- result = self._list_with_filters(
- items, {"status": "active", "type": "search"}
- )
- assert len(result) == 1
-
-
-# --- CardStorage patterns ---
-
-
-class TestCardStorageGetByUserPattern:
- """Tests for card retrieval by user."""
-
- def _get_by_user(self, cards, user_id, limit=50, offset=0):
- user_cards = [c for c in cards if c.get("user_id") == user_id]
- return user_cards[offset : offset + limit]
-
- def test_filters_by_user(self):
- cards = [
- {"id": "1", "user_id": "u1"},
- {"id": "2", "user_id": "u2"},
- {"id": "3", "user_id": "u1"},
- ]
- result = self._get_by_user(cards, "u1")
- assert len(result) == 2
- assert all(c["user_id"] == "u1" for c in result)
-
- def test_respects_limit(self):
- cards = [{"id": str(i), "user_id": "u1"} for i in range(10)]
- result = self._get_by_user(cards, "u1", limit=3)
- assert len(result) == 3
-
- def test_respects_offset(self):
- cards = [{"id": str(i), "user_id": "u1"} for i in range(10)]
- result = self._get_by_user(cards, "u1", offset=5, limit=2)
- assert result[0]["id"] == "5"
-
- def test_no_cards_for_user(self):
- cards = [{"id": "1", "user_id": "u1"}]
- result = self._get_by_user(cards, "u2")
- assert result == []
-
-
-class TestCardVersioningPattern:
- """Tests for card versioning patterns."""
-
- def _get_latest_version(self, versions, card_id):
- card_versions = [v for v in versions if v.get("card_id") == card_id]
- if not card_versions:
- return None
- return max(card_versions, key=lambda v: v.get("version_number", 0))
-
- def test_returns_highest_version(self):
- versions = [
- {"card_id": "c1", "version_number": 1, "data": "v1"},
- {"card_id": "c1", "version_number": 2, "data": "v2"},
- {"card_id": "c1", "version_number": 3, "data": "v3"},
- ]
- result = self._get_latest_version(versions, "c1")
- assert result["version_number"] == 3
- assert result["data"] == "v3"
-
- def test_returns_none_for_missing_card(self):
- versions = [{"card_id": "c1", "version_number": 1}]
- result = self._get_latest_version(versions, "c2")
- assert result is None
-
- def test_single_version(self):
- versions = [{"card_id": "c1", "version_number": 1}]
- result = self._get_latest_version(versions, "c1")
- assert result["version_number"] == 1
-
-
-class TestCardArchivePattern:
- """Tests for card archive/pin patterns."""
-
- def test_archive_sets_flag(self):
- card = {"id": "c1", "archived": False}
- card["archived"] = True
- assert card["archived"] is True
-
- def test_pin_sets_flag(self):
- card = {"id": "c1", "pinned": False}
- card["pinned"] = True
- assert card["pinned"] is True
-
- def test_unpin_clears_flag(self):
- card = {"id": "c1", "pinned": True}
- card["pinned"] = False
- assert card["pinned"] is False
-
-
-# --- SubscriptionStorage patterns ---
-
-
-class TestActiveSubscriptionsPattern:
- """Tests for active subscription filtering."""
-
- def _get_active(self, subs, user_id=None):
- active = [s for s in subs if s.get("is_active", True)]
- if user_id:
- active = [s for s in active if s.get("user_id") == user_id]
- return active
-
- def test_filters_active_only(self):
- subs = [
- {"id": "1", "is_active": True},
- {"id": "2", "is_active": False},
- {"id": "3", "is_active": True},
- ]
- result = self._get_active(subs)
- assert len(result) == 2
-
- def test_filters_by_user(self):
- subs = [
- {"id": "1", "is_active": True, "user_id": "u1"},
- {"id": "2", "is_active": True, "user_id": "u2"},
- ]
- result = self._get_active(subs, "u1")
- assert len(result) == 1
- assert result[0]["user_id"] == "u1"
-
- def test_defaults_to_active(self):
- subs = [{"id": "1"}] # No is_active key
- result = self._get_active(subs)
- assert len(result) == 1
-
-
-class TestDueSubscriptionsPattern:
- """Tests for due subscription detection."""
-
- def _get_due(self, subs, limit=100):
- now = datetime.now(timezone.utc)
- due = [
- s
- for s in subs
- if s.get("is_active", True)
- and s.get("next_refresh")
- and s["next_refresh"] <= now
- ]
- return due[:limit]
-
- def test_detects_past_due(self):
- past = datetime.now(timezone.utc) - timedelta(hours=1)
- subs = [{"id": "1", "is_active": True, "next_refresh": past}]
- result = self._get_due(subs)
- assert len(result) == 1
-
- def test_excludes_future(self):
- future = datetime.now(timezone.utc) + timedelta(hours=1)
- subs = [{"id": "1", "is_active": True, "next_refresh": future}]
- result = self._get_due(subs)
- assert len(result) == 0
-
- def test_excludes_inactive(self):
- past = datetime.now(timezone.utc) - timedelta(hours=1)
- subs = [{"id": "1", "is_active": False, "next_refresh": past}]
- result = self._get_due(subs)
- assert len(result) == 0
-
- def test_excludes_no_next_refresh(self):
- subs = [{"id": "1", "is_active": True}]
- result = self._get_due(subs)
- assert len(result) == 0
-
- def test_respects_limit(self):
- past = datetime.now(timezone.utc) - timedelta(hours=1)
- subs = [
- {"id": str(i), "is_active": True, "next_refresh": past}
- for i in range(10)
- ]
- result = self._get_due(subs, limit=3)
- assert len(result) == 3
-
-
-class TestRefreshTimeUpdatePattern:
- """Tests for refresh time update patterns."""
-
- def _update_refresh_time(self, sub, last_refresh, next_refresh):
- sub["last_refresh"] = last_refresh
- sub["next_refresh"] = next_refresh
- return sub
-
- def test_updates_both_times(self):
- sub = {"id": "1"}
- now = datetime.now(timezone.utc)
- next_time = now + timedelta(hours=1)
- result = self._update_refresh_time(sub, now, next_time)
- assert result["last_refresh"] == now
- assert result["next_refresh"] == next_time
-
- def test_next_refresh_calculation(self):
- now = datetime.now(timezone.utc)
- interval_minutes = 60
- next_refresh = now + timedelta(minutes=interval_minutes)
- assert next_refresh > now
- delta = (next_refresh - now).total_seconds()
- assert abs(delta - 3600) < 1
-
-
-class TestSubscriptionStatsPattern:
- """Tests for subscription stats update pattern."""
-
- def _increment_stats(self, sub, results_count):
- sub["refresh_count"] = sub.get("refresh_count", 0) + 1
- sub["total_results"] = sub.get("total_results", 0) + results_count
- return sub
-
- def test_increments_refresh_count(self):
- sub = {"refresh_count": 5}
- result = self._increment_stats(sub, 10)
- assert result["refresh_count"] == 6
-
- def test_adds_results_count(self):
- sub = {"total_results": 50}
- result = self._increment_stats(sub, 10)
- assert result["total_results"] == 60
-
- def test_initializes_from_zero(self):
- sub = {}
- result = self._increment_stats(sub, 5)
- assert result["refresh_count"] == 1
- assert result["total_results"] == 5
-
-
-class TestSubscriptionStatusTransitions:
- """Tests for subscription status transition patterns."""
-
- def test_pause_sets_status(self):
- sub = {"status": "active"}
- sub["status"] = "paused"
- assert sub["status"] == "paused"
-
- def test_resume_sets_status(self):
- sub = {"status": "paused"}
- sub["status"] = "active"
- assert sub["status"] == "active"
-
- def test_expire_sets_status(self):
- sub = {"status": "active"}
- sub["status"] = "expired"
- assert sub["status"] == "expired"
-
- def test_valid_statuses(self):
- valid = ["active", "paused", "expired"]
- for status in valid:
- assert status in valid
-
-
-# --- RatingStorage patterns ---
-
-
-class TestRatingUpsertPattern:
- """Tests for rating upsert pattern."""
-
- def _upsert_rating(self, ratings, user_id, item_id, rating_type, value):
- key = (user_id, item_id, rating_type)
- existing = ratings.get(key)
- if existing:
- existing["value"] = value
- existing["updated_at"] = datetime.now(timezone.utc)
- return existing["id"]
- new_id = str(uuid.uuid4())
- ratings[key] = {
- "id": new_id,
- "user_id": user_id,
- "item_id": item_id,
- "rating_type": rating_type,
- "value": value,
- "created_at": datetime.now(timezone.utc),
- }
- return new_id
-
- def test_creates_new_rating(self):
- ratings = {}
- rating_id = self._upsert_rating(
- ratings, "u1", "item1", "relevance", "up"
- )
- assert len(ratings) == 1
- assert rating_id is not None
-
- def test_updates_existing_rating(self):
- ratings = {}
- id1 = self._upsert_rating(ratings, "u1", "item1", "relevance", "up")
- id2 = self._upsert_rating(ratings, "u1", "item1", "relevance", "down")
- assert id1 == id2
- assert len(ratings) == 1
-
-
-class TestRatingSummaryPattern:
- """Tests for rating summary aggregation."""
-
- def _get_summary(self, ratings, item_id):
- item_ratings = [r for r in ratings if r.get("item_id") == item_id]
- up_count = sum(1 for r in item_ratings if r.get("value") == "up")
- down_count = sum(1 for r in item_ratings if r.get("value") == "down")
- return {
- "item_id": item_id,
- "up_count": up_count,
- "down_count": down_count,
- "total": len(item_ratings),
- }
-
- def test_counts_up_votes(self):
- ratings = [
- {"item_id": "i1", "value": "up"},
- {"item_id": "i1", "value": "up"},
- {"item_id": "i1", "value": "down"},
- ]
- summary = self._get_summary(ratings, "i1")
- assert summary["up_count"] == 2
-
- def test_counts_down_votes(self):
- ratings = [
- {"item_id": "i1", "value": "up"},
- {"item_id": "i1", "value": "down"},
- {"item_id": "i1", "value": "down"},
- ]
- summary = self._get_summary(ratings, "i1")
- assert summary["down_count"] == 2
-
- def test_total_count(self):
- ratings = [{"item_id": "i1", "value": "up"} for _ in range(5)]
- summary = self._get_summary(ratings, "i1")
- assert summary["total"] == 5
-
- def test_empty_ratings(self):
- summary = self._get_summary([], "i1")
- assert summary["up_count"] == 0
- assert summary["down_count"] == 0
-
-
-# --- PreferenceStorage patterns ---
-
-
-class TestPreferenceUpsertPattern:
- """Tests for preference upsert pattern."""
-
- def _upsert_preferences(self, storage, user_id, prefs):
- if user_id in storage:
- storage[user_id].update(prefs)
- storage[user_id]["updated_at"] = datetime.now(timezone.utc)
- else:
- storage[user_id] = {
- **prefs,
- "user_id": user_id,
- "created_at": datetime.now(timezone.utc),
- }
- return user_id
-
- def test_creates_new_preferences(self):
- storage = {}
- self._upsert_preferences(storage, "u1", {"theme": "dark"})
- assert "u1" in storage
- assert storage["u1"]["theme"] == "dark"
-
- def test_updates_existing_preferences(self):
- storage = {"u1": {"theme": "light"}}
- self._upsert_preferences(storage, "u1", {"theme": "dark"})
- assert storage["u1"]["theme"] == "dark"
-
-
-class TestLikedItemsPattern:
- """Tests for liked/disliked items management."""
-
- def _add_liked(self, prefs, item_id):
- if "liked_items" not in prefs:
- prefs["liked_items"] = []
- if item_id not in prefs["liked_items"]:
- prefs["liked_items"].append(item_id)
- return True
-
- def _add_disliked(self, prefs, item_id):
- if "disliked_items" not in prefs:
- prefs["disliked_items"] = []
- if item_id not in prefs["disliked_items"]:
- prefs["disliked_items"].append(item_id)
- return True
-
- def test_adds_to_liked(self):
- prefs = {}
- self._add_liked(prefs, "item1")
- assert "item1" in prefs["liked_items"]
-
- def test_no_duplicate_liked(self):
- prefs = {"liked_items": ["item1"]}
- self._add_liked(prefs, "item1")
- assert prefs["liked_items"].count("item1") == 1
-
- def test_adds_to_disliked(self):
- prefs = {}
- self._add_disliked(prefs, "item1")
- assert "item1" in prefs["disliked_items"]
-
-
-# --- SearchHistoryStorage patterns ---
-
-
-class TestSearchRecordingPattern:
- """Tests for search history recording."""
-
- def _record_search(self, history, user_id, query, search_data):
- search_id = str(uuid.uuid4())
- history.append(
- {
- "id": search_id,
- "user_id": user_id,
- "query": query,
- "timestamp": datetime.now(timezone.utc),
- **search_data,
- }
- )
- return search_id
-
- def test_creates_search_record(self):
- history = []
- search_id = self._record_search(history, "u1", "AI news", {})
- assert len(history) == 1
- assert search_id is not None
-
- def test_includes_timestamp(self):
- history = []
- self._record_search(history, "u1", "AI news", {})
- assert "timestamp" in history[0]
-
- def test_includes_search_data(self):
- history = []
- self._record_search(history, "u1", "AI", {"results_count": 10})
- assert history[0]["results_count"] == 10
-
-
-class TestRecentSearchesPattern:
- """Tests for recent searches retrieval."""
-
- def _get_recent(self, history, user_id, hours=48, limit=50):
- cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
- user_searches = [
- s
- for s in history
- if s.get("user_id") == user_id
- and s.get("timestamp", cutoff) >= cutoff
- ]
- return user_searches[:limit]
-
- def test_filters_by_user(self):
- now = datetime.now(timezone.utc)
- history = [
- {"user_id": "u1", "timestamp": now},
- {"user_id": "u2", "timestamp": now},
- ]
- result = self._get_recent(history, "u1")
- assert len(result) == 1
-
- def test_filters_by_time(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(hours=100)
- history = [
- {"user_id": "u1", "timestamp": now},
- {"user_id": "u1", "timestamp": old},
- ]
- result = self._get_recent(history, "u1", hours=48)
- assert len(result) == 1
-
- def test_respects_limit(self):
- now = datetime.now(timezone.utc)
- history = [{"user_id": "u1", "timestamp": now} for _ in range(100)]
- result = self._get_recent(history, "u1", limit=10)
- assert len(result) == 10
-
-
-class TestSearchSubscriptionLinkPattern:
- """Tests for linking searches to subscriptions."""
-
- def test_link_creates_reference(self):
- search = {"id": "s1", "subscription_id": None}
- search["subscription_id"] = "sub-123"
- assert search["subscription_id"] == "sub-123"
-
- def test_link_is_optional(self):
- search = {"id": "s1"}
- assert search.get("subscription_id") is None
-
-
-# --- NewsItemStorage patterns ---
-
-
-class TestNewsItemBatchPattern:
- """Tests for batch news item storage."""
-
- def _store_batch(self, storage, items):
- ids = []
- for item in items:
- item_id = str(uuid.uuid4())
- item["id"] = item_id
- item["created_at"] = datetime.now(timezone.utc)
- storage.append(item)
- ids.append(item_id)
- return ids
-
- def test_returns_all_ids(self):
- storage = []
- items = [{"headline": "A"}, {"headline": "B"}, {"headline": "C"}]
- ids = self._store_batch(storage, items)
- assert len(ids) == 3
-
- def test_adds_all_items(self):
- storage = []
- items = [{"headline": "A"}, {"headline": "B"}]
- self._store_batch(storage, items)
- assert len(storage) == 2
-
- def test_adds_timestamps(self):
- storage = []
- self._store_batch(storage, [{"headline": "A"}])
- assert "created_at" in storage[0]
-
-
-class TestNewsItemVotesPattern:
- """Tests for news item vote update patterns."""
-
- def _update_votes(self, item, vote_type):
- if vote_type == "up":
- item["upvotes"] = item.get("upvotes", 0) + 1
- elif vote_type == "down":
- item["downvotes"] = item.get("downvotes", 0) + 1
- return True
-
- def test_increment_upvotes(self):
- item = {"upvotes": 5}
- self._update_votes(item, "up")
- assert item["upvotes"] == 6
-
- def test_increment_downvotes(self):
- item = {"downvotes": 3}
- self._update_votes(item, "down")
- assert item["downvotes"] == 4
-
- def test_initializes_from_zero(self):
- item = {}
- self._update_votes(item, "up")
- assert item["upvotes"] == 1
-
-
-class TestNewsItemCleanupPattern:
- """Tests for old news item cleanup."""
-
- def _cleanup_old(self, items, days=7):
- cutoff = datetime.now(timezone.utc) - timedelta(days=days)
- old_items = [i for i in items if i.get("created_at", cutoff) < cutoff]
- for item in old_items:
- items.remove(item)
- return len(old_items)
-
- def test_removes_old_items(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(days=10)
- items = [{"id": "1", "created_at": old}, {"id": "2", "created_at": now}]
- deleted = self._cleanup_old(items, days=7)
- assert deleted == 1
- assert len(items) == 1
-
- def test_keeps_recent_items(self):
- now = datetime.now(timezone.utc)
- items = [{"id": "1", "created_at": now}]
- deleted = self._cleanup_old(items, days=7)
- assert deleted == 0
- assert len(items) == 1
-
- def test_returns_deleted_count(self):
- old = datetime.now(timezone.utc) - timedelta(days=10)
- items = [{"id": str(i), "created_at": old} for i in range(5)]
- deleted = self._cleanup_old(items, days=7)
- assert deleted == 5
-
-
-class TestNewsCategoryFilterPattern:
- """Tests for news item category filtering."""
-
- def _get_by_category(self, items, category, limit=50):
- filtered = [i for i in items if i.get("category") == category]
- return filtered[:limit]
-
- def test_filters_by_category(self):
- items = [
- {"id": "1", "category": "Tech"},
- {"id": "2", "category": "Science"},
- {"id": "3", "category": "Tech"},
- ]
- result = self._get_by_category(items, "Tech")
- assert len(result) == 2
-
- def test_empty_for_unknown_category(self):
- items = [{"id": "1", "category": "Tech"}]
- result = self._get_by_category(items, "Sports")
- assert result == []
-
- def test_respects_limit(self):
- items = [{"id": str(i), "category": "Tech"} for i in range(100)]
- result = self._get_by_category(items, "Tech", limit=10)
- assert len(result) == 10
diff --git a/tests/news/test_user_session_patterns_behavior.py b/tests/news/test_user_session_patterns_behavior.py
deleted file mode 100644
index 24b3672d48..0000000000
--- a/tests/news/test_user_session_patterns_behavior.py
+++ /dev/null
@@ -1,570 +0,0 @@
-"""
-Deep behavioral tests for user session management patterns.
-Tests session storage, activity tracking, credential management,
-and cleanup logic patterns.
-"""
-
-from datetime import datetime, timezone, timedelta
-import threading
-
-
-# --- User session structure ---
-
-
-class TestUserSessionStructure:
- """Tests for user session data structure."""
-
- def _create_session(self, user_id):
- return {
- "user_id": user_id,
- "last_activity": datetime.now(timezone.utc),
- "scheduled_jobs": set(),
- }
-
- def test_has_user_id(self):
- session = self._create_session("user1")
- assert session["user_id"] == "user1"
-
- def test_no_password_in_session(self):
- session = self._create_session("user1")
- assert "password" not in session
-
- def test_has_last_activity(self):
- session = self._create_session("user1")
- assert "last_activity" in session
- assert isinstance(session["last_activity"], datetime)
-
- def test_has_scheduled_jobs_set(self):
- session = self._create_session("user1")
- assert "scheduled_jobs" in session
- assert isinstance(session["scheduled_jobs"], set)
-
- def test_jobs_initially_empty(self):
- session = self._create_session("user1")
- assert len(session["scheduled_jobs"]) == 0
-
-
-# --- Session registration patterns ---
-
-
-class TestSessionRegistration:
- """Tests for user session registration patterns."""
-
- def _register_user(self, sessions, credential_store, user_id, password):
- sessions[user_id] = {
- "last_activity": datetime.now(timezone.utc),
- "scheduled_jobs": set(),
- }
- credential_store[user_id] = password
- return True
-
- def test_adds_new_user(self):
- sessions, creds = {}, {}
- self._register_user(sessions, creds, "user1", "pass")
- assert "user1" in sessions
-
- def test_stores_password_in_credential_store(self):
- sessions, creds = {}, {}
- self._register_user(sessions, creds, "user1", "mysecret")
- assert "password" not in sessions["user1"]
- assert creds["user1"] == "mysecret"
-
- def test_sets_initial_activity(self):
- sessions, creds = {}, {}
- before = datetime.now(timezone.utc)
- self._register_user(sessions, creds, "user1", "pass")
- after = datetime.now(timezone.utc)
- assert before <= sessions["user1"]["last_activity"] <= after
-
-
-class TestSessionUpdate:
- """Tests for session update patterns."""
-
- def _update_session(
- self, sessions, credential_store, user_id, password=None
- ):
- if user_id not in sessions:
- return False
- sessions[user_id]["last_activity"] = datetime.now(timezone.utc)
- if password:
- credential_store[user_id] = password
- return True
-
- def test_updates_activity_time(self):
- sessions = {
- "user1": {
- "last_activity": datetime.now(timezone.utc)
- - timedelta(hours=1),
- "scheduled_jobs": set(),
- }
- }
- self._update_session(sessions, {}, "user1")
- assert (
- sessions["user1"]["last_activity"]
- > sessions["user1"]["last_activity"]
- or True
- )
- # Just verify it was updated to a recent time
- assert (
- datetime.now(timezone.utc) - sessions["user1"]["last_activity"]
- ).total_seconds() < 5
-
- def test_updates_password_in_credential_store(self):
- sessions = {
- "user1": {
- "last_activity": datetime.now(timezone.utc),
- "scheduled_jobs": set(),
- }
- }
- creds = {"user1": "old"}
- self._update_session(sessions, creds, "user1", "newpass")
- assert creds["user1"] == "newpass"
- assert "password" not in sessions["user1"]
-
- def test_returns_false_for_missing_user(self):
- sessions = {}
- result = self._update_session(sessions, {}, "unknown")
- assert result is False
-
-
-# --- Session unregistration patterns ---
-
-
-class TestSessionUnregistration:
- """Tests for user session removal patterns."""
-
- def _unregister_user(self, sessions, user_id):
- if user_id not in sessions:
- return False
- del sessions[user_id]
- return True
-
- def test_removes_user(self):
- sessions = {"user1": {}, "user2": {}}
- self._unregister_user(sessions, "user1")
- assert "user1" not in sessions
- assert "user2" in sessions
-
- def test_returns_false_for_missing(self):
- sessions = {}
- result = self._unregister_user(sessions, "unknown")
- assert result is False
-
-
-# --- Activity tracking patterns ---
-
-
-class TestActivityTracking:
- """Tests for user activity tracking patterns."""
-
- def _is_active(self, sessions, user_id, retention_hours=48):
- if user_id not in sessions:
- return False
- last_activity = sessions[user_id].get("last_activity")
- if not last_activity:
- return False
- cutoff = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
- return last_activity >= cutoff
-
- def test_recent_activity_is_active(self):
- sessions = {
- "user1": {
- "last_activity": datetime.now(timezone.utc) - timedelta(hours=1)
- }
- }
- assert self._is_active(sessions, "user1") is True
-
- def test_old_activity_not_active(self):
- sessions = {
- "user1": {
- "last_activity": datetime.now(timezone.utc)
- - timedelta(hours=100)
- }
- }
- assert self._is_active(sessions, "user1") is False
-
- def test_missing_user_not_active(self):
- sessions = {}
- assert self._is_active(sessions, "unknown") is False
-
- def test_respects_retention_hours(self):
- sessions = {
- "user1": {
- "last_activity": datetime.now(timezone.utc)
- - timedelta(hours=10)
- }
- }
- assert self._is_active(sessions, "user1", retention_hours=12) is True
- assert self._is_active(sessions, "user1", retention_hours=8) is False
-
-
-class TestActivityCleanup:
- """Tests for inactive session cleanup patterns."""
-
- def _cleanup_inactive(self, sessions, retention_hours=48):
- cutoff = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
- inactive_users = [
- user_id
- for user_id, session in sessions.items()
- if session.get("last_activity", cutoff) < cutoff
- ]
- for user_id in inactive_users:
- del sessions[user_id]
- return len(inactive_users)
-
- def test_removes_inactive_users(self):
- old_time = datetime.now(timezone.utc) - timedelta(hours=100)
- sessions = {
- "active": {"last_activity": datetime.now(timezone.utc)},
- "inactive": {"last_activity": old_time},
- }
- count = self._cleanup_inactive(sessions)
- assert count == 1
- assert "inactive" not in sessions
- assert "active" in sessions
-
- def test_returns_count(self):
- old_time = datetime.now(timezone.utc) - timedelta(hours=100)
- sessions = {f"user{i}": {"last_activity": old_time} for i in range(5)}
- count = self._cleanup_inactive(sessions)
- assert count == 5
-
- def test_keeps_all_active(self):
- sessions = {
- "user1": {"last_activity": datetime.now(timezone.utc)},
- "user2": {"last_activity": datetime.now(timezone.utc)},
- }
- count = self._cleanup_inactive(sessions)
- assert count == 0
- assert len(sessions) == 2
-
-
-# --- Job tracking patterns ---
-
-
-class TestJobTracking:
- """Tests for scheduled job tracking patterns."""
-
- def _add_job(self, sessions, user_id, job_id):
- if user_id not in sessions:
- return False
- sessions[user_id]["scheduled_jobs"].add(job_id)
- return True
-
- def _remove_job(self, sessions, user_id, job_id):
- if user_id not in sessions:
- return False
- sessions[user_id]["scheduled_jobs"].discard(job_id)
- return True
-
- def _get_jobs(self, sessions, user_id):
- if user_id not in sessions:
- return set()
- return sessions[user_id].get("scheduled_jobs", set())
-
- def test_add_job(self):
- sessions = {"user1": {"scheduled_jobs": set()}}
- self._add_job(sessions, "user1", "job-123")
- assert "job-123" in sessions["user1"]["scheduled_jobs"]
-
- def test_add_multiple_jobs(self):
- sessions = {"user1": {"scheduled_jobs": set()}}
- self._add_job(sessions, "user1", "job-1")
- self._add_job(sessions, "user1", "job-2")
- assert len(sessions["user1"]["scheduled_jobs"]) == 2
-
- def test_remove_job(self):
- sessions = {"user1": {"scheduled_jobs": {"job-1", "job-2"}}}
- self._remove_job(sessions, "user1", "job-1")
- assert "job-1" not in sessions["user1"]["scheduled_jobs"]
- assert "job-2" in sessions["user1"]["scheduled_jobs"]
-
- def test_get_jobs(self):
- sessions = {"user1": {"scheduled_jobs": {"a", "b", "c"}}}
- jobs = self._get_jobs(sessions, "user1")
- assert len(jobs) == 3
-
- def test_get_jobs_unknown_user(self):
- sessions = {}
- jobs = self._get_jobs(sessions, "unknown")
- assert jobs == set()
-
-
-class TestJobCountAggregation:
- """Tests for job count aggregation patterns."""
-
- def _total_jobs(self, sessions):
- return sum(
- len(session.get("scheduled_jobs", set()))
- for session in sessions.values()
- )
-
- def test_counts_all_jobs(self):
- sessions = {
- "u1": {"scheduled_jobs": {"j1", "j2"}},
- "u2": {"scheduled_jobs": {"j3"}},
- }
- total = self._total_jobs(sessions)
- assert total == 3
-
- def test_empty_sessions(self):
- sessions = {}
- total = self._total_jobs(sessions)
- assert total == 0
-
- def test_users_with_no_jobs(self):
- sessions = {
- "u1": {"scheduled_jobs": set()},
- "u2": {"scheduled_jobs": set()},
- }
- total = self._total_jobs(sessions)
- assert total == 0
-
-
-# --- Thread safety patterns ---
-
-
-class TestThreadSafetyPatterns:
- """Tests for thread-safe access patterns."""
-
- def test_lock_context_manager(self):
- lock = threading.Lock()
- with lock:
- # Critical section
- value = 42
- assert value == 42
-
- def test_lock_acquire_release(self):
- lock = threading.Lock()
- acquired = lock.acquire()
- assert acquired is True
- lock.release()
-
- def test_copy_before_iteration(self):
- sessions = {"u1": {}, "u2": {}, "u3": {}}
- # Copy keys before iterating to avoid modification during iteration
- user_ids = list(sessions.keys())
- for user_id in user_ids:
- pass
- assert len(user_ids) == 3
-
-
-# --- Password management patterns ---
-
-
-class TestCredentialManagement:
- """Tests for credential store patterns (passwords stored separately)."""
-
- def _has_credential(self, credential_store, user_id):
- return bool(credential_store.get(user_id))
-
- def _get_credential(self, credential_store, user_id):
- return credential_store.get(user_id)
-
- def test_has_credential_true(self):
- creds = {"user1": "secret"}
- assert self._has_credential(creds, "user1") is True
-
- def test_has_credential_false_empty(self):
- creds = {"user1": ""}
- assert self._has_credential(creds, "user1") is False
-
- def test_has_credential_false_missing(self):
- creds = {}
- assert self._has_credential(creds, "user1") is False
-
- def test_get_credential(self):
- creds = {"user1": "secret"}
- assert self._get_credential(creds, "user1") == "secret"
-
- def test_get_credential_missing_user(self):
- creds = {}
- assert self._get_credential(creds, "unknown") is None
-
-
-# --- Session info formatting patterns ---
-
-
-class TestSessionInfoFormatting:
- """Tests for session info formatting patterns."""
-
- def _format_session_info(self, session, has_credential=False):
- return {
- "has_password": has_credential,
- "last_activity": session.get("last_activity").isoformat()
- if session.get("last_activity")
- else None,
- "scheduled_jobs_count": len(session.get("scheduled_jobs", set())),
- }
-
- def test_has_password_true(self):
- session = {"scheduled_jobs": set()}
- info = self._format_session_info(session, has_credential=True)
- assert info["has_password"] is True
-
- def test_has_password_false(self):
- session = {"scheduled_jobs": set()}
- info = self._format_session_info(session, has_credential=False)
- assert info["has_password"] is False
-
- def test_formats_last_activity(self):
- session = {
- "last_activity": datetime(
- 2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc
- ),
- "scheduled_jobs": set(),
- }
- info = self._format_session_info(session)
- assert "2025-06-15" in info["last_activity"]
-
- def test_counts_jobs(self):
- session = {"scheduled_jobs": {"j1", "j2", "j3"}}
- info = self._format_session_info(session)
- assert info["scheduled_jobs_count"] == 3
-
-
-# --- Active user count patterns ---
-
-
-class TestActiveUserCount:
- """Tests for active user counting patterns."""
-
- def _count_active_users(self, sessions, retention_hours=48):
- cutoff = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
- return sum(
- 1
- for session in sessions.values()
- if session.get("last_activity", cutoff) >= cutoff
- )
-
- def test_counts_active_only(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(hours=100)
- sessions = {
- "active1": {"last_activity": now},
- "active2": {"last_activity": now},
- "inactive": {"last_activity": old},
- }
- count = self._count_active_users(sessions)
- assert count == 2
-
- def test_all_active(self):
- now = datetime.now(timezone.utc)
- sessions = {f"u{i}": {"last_activity": now} for i in range(5)}
- count = self._count_active_users(sessions)
- assert count == 5
-
- def test_none_active(self):
- old = datetime.now(timezone.utc) - timedelta(hours=100)
- sessions = {f"u{i}": {"last_activity": old} for i in range(5)}
- count = self._count_active_users(sessions)
- assert count == 0
-
-
-# --- Session existence patterns ---
-
-
-class TestSessionExistence:
- """Tests for session existence check patterns."""
-
- def _has_session(self, sessions, user_id):
- return user_id in sessions
-
- def _get_or_create_session(
- self, sessions, credential_store, user_id, password
- ):
- if user_id not in sessions:
- sessions[user_id] = {
- "last_activity": datetime.now(timezone.utc),
- "scheduled_jobs": set(),
- }
- credential_store[user_id] = password
- return sessions[user_id], True # Created
- return sessions[user_id], False # Existed
-
- def test_has_session_true(self):
- sessions = {"user1": {}}
- assert self._has_session(sessions, "user1") is True
-
- def test_has_session_false(self):
- sessions = {}
- assert self._has_session(sessions, "user1") is False
-
- def test_get_or_create_new(self):
- sessions, creds = {}, {}
- session, created = self._get_or_create_session(
- sessions, creds, "user1", "pass"
- )
- assert created is True
- assert "user1" in sessions
- assert "password" not in session
- assert creds["user1"] == "pass"
-
- def test_get_or_create_existing(self):
- sessions = {"user1": {"scheduled_jobs": set()}}
- creds = {"user1": "old"}
- session, created = self._get_or_create_session(
- sessions, creds, "user1", "new"
- )
- assert created is False
- # Credential not updated for existing session
- assert creds["user1"] == "old"
-
-
-# --- Retention policy patterns ---
-
-
-class TestRetentionPolicy:
- """Tests for session retention policy patterns."""
-
- def test_default_retention_48_hours(self):
- retention_hours = 48
- assert retention_hours == 48
-
- def test_custom_retention(self):
- retention_hours = 24
- cutoff = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
- assert cutoff < datetime.now(timezone.utc)
-
- def test_retention_zero_means_immediate_cleanup(self):
- retention_hours = 0
- cutoff = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
- now = datetime.now(timezone.utc)
- # With 0 retention, only exact now would pass
- assert abs((now - cutoff).total_seconds()) < 1
-
-
-# --- Session clearing patterns ---
-
-
-class TestSessionClearing:
- """Tests for session clearing patterns."""
-
- def _clear_all_sessions(self, sessions):
- count = len(sessions)
- sessions.clear()
- return count
-
- def _clear_user_jobs(self, sessions, user_id):
- if user_id not in sessions:
- return 0
- count = len(sessions[user_id].get("scheduled_jobs", set()))
- sessions[user_id]["scheduled_jobs"] = set()
- return count
-
- def test_clear_all(self):
- sessions = {"u1": {}, "u2": {}, "u3": {}}
- count = self._clear_all_sessions(sessions)
- assert count == 3
- assert len(sessions) == 0
-
- def test_clear_user_jobs(self):
- sessions = {"u1": {"scheduled_jobs": {"j1", "j2", "j3"}}}
- count = self._clear_user_jobs(sessions, "u1")
- assert count == 3
- assert len(sessions["u1"]["scheduled_jobs"]) == 0
-
- def test_clear_jobs_unknown_user(self):
- sessions = {}
- count = self._clear_user_jobs(sessions, "unknown")
- assert count == 0
diff --git a/tests/news/test_utils_logic_behavior.py b/tests/news/test_utils_logic_behavior.py
deleted file mode 100644
index 2592ca76e8..0000000000
--- a/tests/news/test_utils_logic_behavior.py
+++ /dev/null
@@ -1,370 +0,0 @@
-"""
-Deep behavioral tests for core/utils.py pure logic.
-Tests date string generation, ID generation,
-UTC time handling, and hours_ago calculation.
-"""
-
-from datetime import datetime, timezone
-
-
-# --- get_local_date_string timezone handling ---
-
-
-class TestLocalDateStringTimezoneHandling:
- """Tests for get_local_date_string timezone logic."""
-
- def _get_timezone_source(self, settings_manager, env_tz):
- if settings_manager:
- tz = settings_manager.get("app.timezone")
- if tz:
- return tz
- if env_tz:
- return env_tz
- return "UTC"
-
- def test_from_settings_manager(self):
- manager = {"app.timezone": "America/New_York"}
- result = self._get_timezone_source(manager, None)
- assert result == "America/New_York"
-
- def test_from_env_when_no_settings(self):
- result = self._get_timezone_source(None, "Europe/London")
- assert result == "Europe/London"
-
- def test_default_utc(self):
- result = self._get_timezone_source(None, None)
- assert result == "UTC"
-
- def test_settings_takes_precedence(self):
- manager = {"app.timezone": "Asia/Tokyo"}
- result = self._get_timezone_source(manager, "Europe/Paris")
- assert result == "Asia/Tokyo"
-
-
-class TestLocalDateStringFormat:
- """Tests for date string format."""
-
- def _format_date(self, dt):
- return dt.date().isoformat()
-
- def test_iso_format(self):
- dt = datetime(2025, 6, 15, 10, 30, 0, tzinfo=timezone.utc)
- result = self._format_date(dt)
- assert result == "2025-06-15"
-
- def test_single_digit_month(self):
- dt = datetime(2025, 1, 5, 10, 30, 0, tzinfo=timezone.utc)
- result = self._format_date(dt)
- assert result == "2025-01-05"
-
- def test_double_digit_day(self):
- dt = datetime(2025, 12, 31, 10, 30, 0, tzinfo=timezone.utc)
- result = self._format_date(dt)
- assert result == "2025-12-31"
-
-
-class TestTimezoneValidation:
- """Tests for timezone validation fallback."""
-
- def _is_valid_timezone(self, tz_name):
- try:
- from zoneinfo import ZoneInfo
-
- ZoneInfo(tz_name)
- return True
- except Exception:
- return False
-
- def test_valid_timezone(self):
- assert self._is_valid_timezone("UTC") is True
- assert self._is_valid_timezone("America/New_York") is True
-
- def test_invalid_timezone(self):
- assert self._is_valid_timezone("Invalid/Timezone") is False
- assert self._is_valid_timezone("") is False
-
-
-# --- generate_card_id ---
-
-
-class TestGenerateCardId:
- """Tests for generate_card_id UUID generation."""
-
- def _is_valid_uuid(self, value):
- import re
-
- pattern = (
- r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
- )
- return bool(re.match(pattern, value.lower()))
-
- def test_returns_string(self):
- import uuid
-
- card_id = str(uuid.uuid4())
- assert isinstance(card_id, str)
-
- def test_valid_uuid_format(self):
- import uuid
-
- card_id = str(uuid.uuid4())
- assert self._is_valid_uuid(card_id) is True
-
- def test_unique_each_call(self):
- import uuid
-
- id1 = str(uuid.uuid4())
- id2 = str(uuid.uuid4())
- assert id1 != id2
-
- def test_uuid_length(self):
- import uuid
-
- card_id = str(uuid.uuid4())
- assert len(card_id) == 36 # UUID with hyphens
-
-
-# --- generate_subscription_id ---
-
-
-class TestGenerateSubscriptionId:
- """Tests for generate_subscription_id UUID generation."""
-
- def _is_valid_uuid(self, value):
- import re
-
- pattern = (
- r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
- )
- return bool(re.match(pattern, value.lower()))
-
- def test_returns_string(self):
- import uuid
-
- sub_id = str(uuid.uuid4())
- assert isinstance(sub_id, str)
-
- def test_valid_uuid_format(self):
- import uuid
-
- sub_id = str(uuid.uuid4())
- assert self._is_valid_uuid(sub_id) is True
-
-
-# --- utc_now ---
-
-
-class TestUtcNow:
- """Tests for utc_now function."""
-
- def _utc_now(self):
- return datetime.now(timezone.utc)
-
- def test_returns_datetime(self):
- result = self._utc_now()
- assert isinstance(result, datetime)
-
- def test_has_timezone(self):
- result = self._utc_now()
- assert result.tzinfo is not None
-
- def test_timezone_is_utc(self):
- result = self._utc_now()
- assert result.tzinfo == timezone.utc
-
- def test_close_to_now(self):
- before = datetime.now(timezone.utc)
- result = self._utc_now()
- after = datetime.now(timezone.utc)
- assert before <= result <= after
-
-
-# --- hours_ago ---
-
-
-class TestHoursAgo:
- """Tests for hours_ago calculation."""
-
- def _hours_ago(self, dt, now=None):
- if now is None:
- now = datetime.now(timezone.utc)
- if dt.tzinfo is None:
- dt = dt.replace(tzinfo=timezone.utc)
- delta = now - dt
- return delta.total_seconds() / 3600
-
- def test_one_hour_ago(self):
- now = datetime(2025, 6, 15, 11, 0, 0, tzinfo=timezone.utc)
- dt = datetime(2025, 6, 15, 10, 0, 0, tzinfo=timezone.utc)
- result = self._hours_ago(dt, now)
- assert abs(result - 1.0) < 0.01
-
- def test_24_hours_ago(self):
- now = datetime(2025, 6, 15, 10, 0, 0, tzinfo=timezone.utc)
- dt = datetime(2025, 6, 14, 10, 0, 0, tzinfo=timezone.utc)
- result = self._hours_ago(dt, now)
- assert abs(result - 24.0) < 0.01
-
- def test_half_hour_ago(self):
- now = datetime(2025, 6, 15, 10, 30, 0, tzinfo=timezone.utc)
- dt = datetime(2025, 6, 15, 10, 0, 0, tzinfo=timezone.utc)
- result = self._hours_ago(dt, now)
- assert abs(result - 0.5) < 0.01
-
- def test_future_is_negative(self):
- now = datetime(2025, 6, 15, 10, 0, 0, tzinfo=timezone.utc)
- dt = datetime(2025, 6, 15, 11, 0, 0, tzinfo=timezone.utc)
- result = self._hours_ago(dt, now)
- assert result < 0
-
- def test_same_time_is_zero(self):
- now = datetime(2025, 6, 15, 10, 0, 0, tzinfo=timezone.utc)
- result = self._hours_ago(now, now)
- assert abs(result) < 0.01
-
-
-class TestHoursAgoNaiveDatetime:
- """Tests for hours_ago with naive datetime handling."""
-
- def _hours_ago_with_tz_handling(self, dt, now):
- if dt.tzinfo is None:
- dt = dt.replace(tzinfo=timezone.utc)
- delta = now - dt
- return delta.total_seconds() / 3600
-
- def test_naive_datetime_treated_as_utc(self):
- now = datetime(2025, 6, 15, 11, 0, 0, tzinfo=timezone.utc)
- dt_naive = datetime(2025, 6, 15, 10, 0, 0) # No timezone
- result = self._hours_ago_with_tz_handling(dt_naive, now)
- assert abs(result - 1.0) < 0.01
-
-
-# --- Environment variable handling ---
-
-
-class TestEnvVariableHandling:
- """Tests for TZ environment variable handling."""
-
- def _get_tz_from_env(self, env_vars):
- return env_vars.get("TZ")
-
- def test_tz_present(self):
- env = {"TZ": "America/Chicago"}
- result = self._get_tz_from_env(env)
- assert result == "America/Chicago"
-
- def test_tz_not_present(self):
- env = {}
- result = self._get_tz_from_env(env)
- assert result is None
-
- def test_tz_empty_string(self):
- env = {"TZ": ""}
- result = self._get_tz_from_env(env)
- assert result == ""
-
-
-# --- Settings manager fallback ---
-
-
-class TestSettingsManagerFallback:
- """Tests for settings manager error handling."""
-
- def _get_tz_from_settings(self, manager, key):
- try:
- if manager is not None:
- return manager.get(key)
- except Exception:
- pass
- return None
-
- def test_success(self):
- manager = {"app.timezone": "UTC"}
- result = self._get_tz_from_settings(manager, "app.timezone")
- assert result == "UTC"
-
- def test_key_missing(self):
- manager = {}
- result = self._get_tz_from_settings(manager, "app.timezone")
- assert result is None
-
- def test_manager_none(self):
- result = self._get_tz_from_settings(None, "app.timezone")
- assert result is None
-
-
-# --- UUID string format ---
-
-
-class TestUuidStringFormat:
- """Tests for UUID string format patterns."""
-
- def test_lowercase_format(self):
- import uuid
-
- result = str(uuid.uuid4())
- # UUID strings are lowercase
- assert result == result.lower()
-
- def test_hyphen_positions(self):
- import uuid
-
- result = str(uuid.uuid4())
- # Hyphens at positions 8, 13, 18, 23
- assert result[8] == "-"
- assert result[13] == "-"
- assert result[18] == "-"
- assert result[23] == "-"
-
- def test_hex_characters_only(self):
- import uuid
-
- result = str(uuid.uuid4())
- hex_chars = set("0123456789abcdef-")
- assert all(c in hex_chars for c in result)
-
-
-# --- Datetime isoformat patterns ---
-
-
-class TestDatetimeIsoformatPatterns:
- """Tests for datetime isoformat output."""
-
- def test_date_isoformat(self):
- dt = datetime(2025, 6, 15, tzinfo=timezone.utc)
- result = dt.date().isoformat()
- assert result == "2025-06-15"
-
- def test_datetime_isoformat(self):
- dt = datetime(2025, 6, 15, 10, 30, 0, tzinfo=timezone.utc)
- result = dt.isoformat()
- assert "2025-06-15" in result
- assert "10:30:00" in result
-
- def test_isoformat_includes_timezone(self):
- dt = datetime(2025, 6, 15, 10, 30, 0, tzinfo=timezone.utc)
- result = dt.isoformat()
- assert "+00:00" in result
-
-
-# --- Total seconds calculation ---
-
-
-class TestTotalSecondsCalculation:
- """Tests for timedelta total_seconds conversion."""
-
- def _to_hours(self, total_seconds):
- return total_seconds / 3600
-
- def test_one_hour(self):
- assert self._to_hours(3600) == 1.0
-
- def test_half_hour(self):
- assert self._to_hours(1800) == 0.5
-
- def test_24_hours(self):
- assert self._to_hours(86400) == 24.0
-
- def test_fractional_hours(self):
- # 90 minutes = 5400 seconds = 1.5 hours
- assert self._to_hours(5400) == 1.5
diff --git a/tests/news/test_validation_patterns_behavior.py b/tests/news/test_validation_patterns_behavior.py
deleted file mode 100644
index fa51a804be..0000000000
--- a/tests/news/test_validation_patterns_behavior.py
+++ /dev/null
@@ -1,572 +0,0 @@
-"""
-Deep behavioral tests for input validation patterns.
-Tests field validation, schema validation, sanitization,
-and constraint checking logic.
-"""
-
-import re
-from datetime import datetime, timezone
-
-
-# --- String validation patterns ---
-
-
-class TestStringValidation:
- """Tests for string validation patterns."""
-
- def _is_non_empty(self, value):
- """Check if string is non-empty."""
- return isinstance(value, str) and len(value.strip()) > 0
-
- def _has_min_length(self, value, min_len):
- """Check minimum length."""
- return isinstance(value, str) and len(value) >= min_len
-
- def _has_max_length(self, value, max_len):
- """Check maximum length."""
- return isinstance(value, str) and len(value) <= max_len
-
- def _matches_pattern(self, value, pattern):
- """Check if value matches regex pattern."""
- if not isinstance(value, str):
- return False
- return bool(re.match(pattern, value))
-
- def test_non_empty_with_content(self):
- assert self._is_non_empty("hello") is True
-
- def test_non_empty_with_whitespace(self):
- assert self._is_non_empty(" ") is False
-
- def test_non_empty_with_empty(self):
- assert self._is_non_empty("") is False
-
- def test_min_length_valid(self):
- assert self._has_min_length("hello", 3) is True
-
- def test_min_length_too_short(self):
- assert self._has_min_length("hi", 3) is False
-
- def test_max_length_valid(self):
- assert self._has_max_length("hello", 10) is True
-
- def test_max_length_too_long(self):
- assert self._has_max_length("hello world", 5) is False
-
- def test_pattern_match(self):
- assert self._matches_pattern("abc123", r"^[a-z]+\d+$") is True
-
- def test_pattern_no_match(self):
- assert self._matches_pattern("123abc", r"^[a-z]+\d+$") is False
-
-
-class TestEmailValidation:
- """Tests for email validation patterns."""
-
- def _is_valid_email(self, email):
- """Validate email format."""
- if not isinstance(email, str):
- return False
- pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
- return bool(re.match(pattern, email))
-
- def _extract_domain(self, email):
- """Extract domain from email."""
- if "@" not in email:
- return None
- return email.split("@")[1]
-
- def test_valid_email(self):
- assert self._is_valid_email("[email protected]") is True
-
- def test_valid_email_with_dots(self):
- assert self._is_valid_email("[email protected]") is True
-
- def test_invalid_no_at(self):
- assert self._is_valid_email("userexample.com") is False
-
- def test_invalid_no_domain(self):
- assert self._is_valid_email("user@") is False
-
- def test_extract_domain(self):
- assert self._extract_domain("[email protected]") == "example.com"
-
-
-class TestURLValidation:
- """Tests for URL validation patterns."""
-
- def _is_valid_url(self, url):
- """Validate URL format."""
- if not isinstance(url, str):
- return False
- pattern = r"^https?://[^\s/$.?#].[^\s]*$"
- return bool(re.match(pattern, url))
-
- def _is_https(self, url):
- """Check if URL uses HTTPS."""
- return url.startswith("https://")
-
- def _extract_host(self, url):
- """Extract host from URL."""
- match = re.match(r"https?://([^/]+)", url)
- return match.group(1) if match else None
-
- def test_valid_http(self):
- assert self._is_valid_url("http://example.com") is True
-
- def test_valid_https(self):
- assert self._is_valid_url("https://example.com/path") is True
-
- def test_invalid_no_protocol(self):
- assert self._is_valid_url("example.com") is False
-
- def test_is_https(self):
- assert self._is_https("https://example.com") is True
- assert self._is_https("http://example.com") is False
-
- def test_extract_host(self):
- assert self._extract_host("https://example.com/path") == "example.com"
-
-
-# --- Numeric validation patterns ---
-
-
-class TestNumericValidation:
- """Tests for numeric validation patterns."""
-
- def _is_positive(self, value):
- """Check if value is positive."""
- return isinstance(value, (int, float)) and value > 0
-
- def _is_non_negative(self, value):
- """Check if value is non-negative."""
- return isinstance(value, (int, float)) and value >= 0
-
- def _is_in_range(self, value, min_val, max_val):
- """Check if value is in range."""
- return isinstance(value, (int, float)) and min_val <= value <= max_val
-
- def _is_integer(self, value):
- """Check if value is an integer."""
- if isinstance(value, bool):
- return False
- return isinstance(value, int) or (
- isinstance(value, float) and value.is_integer()
- )
-
- def test_positive(self):
- assert self._is_positive(5) is True
- assert self._is_positive(-1) is False
- assert self._is_positive(0) is False
-
- def test_non_negative(self):
- assert self._is_non_negative(0) is True
- assert self._is_non_negative(5) is True
- assert self._is_non_negative(-1) is False
-
- def test_in_range(self):
- assert self._is_in_range(5, 1, 10) is True
- assert self._is_in_range(0, 1, 10) is False
-
- def test_is_integer(self):
- assert self._is_integer(5) is True
- assert self._is_integer(5.0) is True
- assert self._is_integer(5.5) is False
-
-
-class TestPercentageValidation:
- """Tests for percentage validation patterns."""
-
- def _is_valid_percentage(self, value):
- """Check if value is a valid percentage (0-100)."""
- return isinstance(value, (int, float)) and 0 <= value <= 100
-
- def _is_valid_ratio(self, value):
- """Check if value is a valid ratio (0-1)."""
- return isinstance(value, (int, float)) and 0 <= value <= 1
-
- def _percentage_to_ratio(self, percentage):
- """Convert percentage to ratio."""
- return percentage / 100
-
- def test_valid_percentage(self):
- assert self._is_valid_percentage(50) is True
- assert self._is_valid_percentage(0) is True
- assert self._is_valid_percentage(100) is True
-
- def test_invalid_percentage(self):
- assert self._is_valid_percentage(-5) is False
- assert self._is_valid_percentage(101) is False
-
- def test_valid_ratio(self):
- assert self._is_valid_ratio(0.5) is True
- assert self._is_valid_ratio(0) is True
- assert self._is_valid_ratio(1) is True
-
- def test_percentage_to_ratio(self):
- assert self._percentage_to_ratio(50) == 0.5
-
-
-# --- Date validation patterns ---
-
-
-class TestDateValidation:
- """Tests for date validation patterns."""
-
- def _is_valid_date_string(self, value, format_str="%Y-%m-%d"):
- """Check if string is a valid date."""
- if not isinstance(value, str):
- return False
- try:
- datetime.strptime(value, format_str)
- return True
- except ValueError:
- return False
-
- def _is_future_date(self, dt):
- """Check if date is in the future."""
- if not isinstance(dt, datetime):
- return False
- now = datetime.now(timezone.utc)
- if dt.tzinfo is None:
- dt = dt.replace(tzinfo=timezone.utc)
- return dt > now
-
- def _is_past_date(self, dt):
- """Check if date is in the past."""
- if not isinstance(dt, datetime):
- return False
- now = datetime.now(timezone.utc)
- if dt.tzinfo is None:
- dt = dt.replace(tzinfo=timezone.utc)
- return dt < now
-
- def test_valid_date_string(self):
- assert self._is_valid_date_string("2025-06-15") is True
-
- def test_invalid_date_string(self):
- assert self._is_valid_date_string("2025-13-45") is False
-
- def test_invalid_format(self):
- assert self._is_valid_date_string("15/06/2025") is False
-
- def test_future_date(self):
- future = datetime(2030, 1, 1, tzinfo=timezone.utc)
- assert self._is_future_date(future) is True
-
- def test_past_date(self):
- past = datetime(2020, 1, 1, tzinfo=timezone.utc)
- assert self._is_past_date(past) is True
-
-
-# --- Collection validation patterns ---
-
-
-class TestCollectionValidation:
- """Tests for collection validation patterns."""
-
- def _is_non_empty_list(self, value):
- """Check if value is a non-empty list."""
- return isinstance(value, list) and len(value) > 0
-
- def _has_min_items(self, value, min_count):
- """Check minimum item count."""
- return isinstance(value, (list, tuple)) and len(value) >= min_count
-
- def _has_max_items(self, value, max_count):
- """Check maximum item count."""
- return isinstance(value, (list, tuple)) and len(value) <= max_count
-
- def _all_match_type(self, items, expected_type):
- """Check all items are of expected type."""
- return all(isinstance(item, expected_type) for item in items)
-
- def test_non_empty_list(self):
- assert self._is_non_empty_list([1, 2, 3]) is True
- assert self._is_non_empty_list([]) is False
-
- def test_min_items(self):
- assert self._has_min_items([1, 2, 3], 2) is True
- assert self._has_min_items([1], 2) is False
-
- def test_max_items(self):
- assert self._has_max_items([1, 2], 5) is True
- assert self._has_max_items([1, 2, 3, 4, 5, 6], 5) is False
-
- def test_all_match_type(self):
- assert self._all_match_type([1, 2, 3], int) is True
- assert self._all_match_type([1, "2", 3], int) is False
-
-
-class TestUniqueValidation:
- """Tests for uniqueness validation patterns."""
-
- def _has_unique_items(self, items):
- """Check if all items are unique."""
- return len(items) == len(set(items))
-
- def _has_unique_field(self, items, field):
- """Check if field values are unique across items."""
- values = [item.get(field) for item in items]
- return len(values) == len(set(values))
-
- def _find_duplicates(self, items):
- """Find duplicate items."""
- seen = set()
- duplicates = []
- for item in items:
- if item in seen:
- duplicates.append(item)
- seen.add(item)
- return duplicates
-
- def test_all_unique(self):
- assert self._has_unique_items([1, 2, 3]) is True
-
- def test_has_duplicates(self):
- assert self._has_unique_items([1, 2, 2]) is False
-
- def test_unique_field(self):
- items = [{"id": 1}, {"id": 2}, {"id": 3}]
- assert self._has_unique_field(items, "id") is True
-
- def test_duplicate_field(self):
- items = [{"id": 1}, {"id": 2}, {"id": 1}]
- assert self._has_unique_field(items, "id") is False
-
- def test_find_duplicates(self):
- duplicates = self._find_duplicates([1, 2, 2, 3, 3, 3])
- assert 2 in duplicates
- assert 3 in duplicates
-
-
-# --- Schema validation patterns ---
-
-
-class TestSchemaValidation:
- """Tests for schema validation patterns."""
-
- def _validate_required_fields(self, data, required):
- """Validate required fields are present."""
- missing = [f for f in required if f not in data or data[f] is None]
- return len(missing) == 0, missing
-
- def _validate_field_types(self, data, type_schema):
- """Validate field types."""
- errors = []
- for field, expected_type in type_schema.items():
- if field in data and data[field] is not None:
- if not isinstance(data[field], expected_type):
- errors.append(f"{field}: expected {expected_type.__name__}")
- return len(errors) == 0, errors
-
- def _validate_schema(self, data, schema):
- """Validate data against schema."""
- errors = []
- for field, rules in schema.items():
- value = data.get(field)
- if rules.get("required") and value is None:
- errors.append(f"{field}: required")
- continue
- if value is not None:
- if "type" in rules and not isinstance(value, rules["type"]):
- errors.append(f"{field}: invalid type")
- if "min" in rules and value < rules["min"]:
- errors.append(f"{field}: below minimum")
- if "max" in rules and value > rules["max"]:
- errors.append(f"{field}: above maximum")
- return len(errors) == 0, errors
-
- def test_required_fields_present(self):
- data = {"name": "test", "email": "[email protected]"}
- valid, missing = self._validate_required_fields(data, ["name", "email"])
- assert valid is True
-
- def test_required_fields_missing(self):
- data = {"name": "test"}
- valid, missing = self._validate_required_fields(data, ["name", "email"])
- assert valid is False
- assert "email" in missing
-
- def test_field_types_valid(self):
- data = {"name": "test", "age": 25}
- valid, errors = self._validate_field_types(
- data, {"name": str, "age": int}
- )
- assert valid is True
-
- def test_field_types_invalid(self):
- data = {"name": "test", "age": "25"}
- valid, errors = self._validate_field_types(
- data, {"name": str, "age": int}
- )
- assert valid is False
-
-
-# --- Sanitization patterns ---
-
-
-class TestInputSanitization:
- """Tests for input sanitization patterns."""
-
- def _trim_whitespace(self, value):
- """Trim whitespace from string."""
- return value.strip() if isinstance(value, str) else value
-
- def _normalize_whitespace(self, value):
- """Normalize internal whitespace."""
- if not isinstance(value, str):
- return value
- return " ".join(value.split())
-
- def _remove_control_chars(self, value):
- """Remove control characters."""
- if not isinstance(value, str):
- return value
- return "".join(c for c in value if ord(c) >= 32 or c in "\n\t")
-
- def _truncate(self, value, max_length):
- """Truncate string to max length."""
- if not isinstance(value, str):
- return value
- return value[:max_length]
-
- def test_trim_whitespace(self):
- assert self._trim_whitespace(" hello ") == "hello"
-
- def test_normalize_whitespace(self):
- assert self._normalize_whitespace("hello world") == "hello world"
-
- def test_remove_control_chars(self):
- result = self._remove_control_chars("hello\x00world")
- assert "\x00" not in result
-
- def test_truncate(self):
- assert self._truncate("hello world", 5) == "hello"
-
-
-class TestHTMLSanitization:
- """Tests for HTML sanitization patterns."""
-
- def _strip_html(self, value):
- """Remove all HTML tags."""
- if not isinstance(value, str):
- return value
- return re.sub(r"<[^>]+>", "", value)
-
- def _escape_html(self, value):
- """Escape HTML special characters."""
- if not isinstance(value, str):
- return value
- escapes = {"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;"}
- for char, escape in escapes.items():
- value = value.replace(char, escape)
- return value
-
- def test_strip_html(self):
- result = self._strip_html("<p>Hello <b>World</b></p>")
- assert result == "Hello World"
-
- def test_escape_html(self):
- result = self._escape_html("<script>alert('xss')</script>")
- assert "<" not in result
- assert "&lt;" in result
-
-
-# --- Constraint validation patterns ---
-
-
-class TestConstraintValidation:
- """Tests for constraint validation patterns."""
-
- def _validate_not_before(self, value, min_date):
- """Validate date is not before minimum."""
- if not isinstance(value, datetime):
- return False
- return value >= min_date
-
- def _validate_not_after(self, value, max_date):
- """Validate date is not after maximum."""
- if not isinstance(value, datetime):
- return False
- return value <= max_date
-
- def _validate_one_of(self, value, allowed):
- """Validate value is one of allowed values."""
- return value in allowed
-
- def _validate_none_of(self, value, disallowed):
- """Validate value is not in disallowed values."""
- return value not in disallowed
-
- def test_not_before(self):
- min_date = datetime(2025, 1, 1, tzinfo=timezone.utc)
- value = datetime(2025, 6, 15, tzinfo=timezone.utc)
- assert self._validate_not_before(value, min_date) is True
-
- def test_not_after(self):
- max_date = datetime(2025, 12, 31, tzinfo=timezone.utc)
- value = datetime(2025, 6, 15, tzinfo=timezone.utc)
- assert self._validate_not_after(value, max_date) is True
-
- def test_one_of(self):
- assert self._validate_one_of("active", ["active", "inactive"]) is True
- assert self._validate_one_of("unknown", ["active", "inactive"]) is False
-
- def test_none_of(self):
- assert self._validate_none_of("valid", ["invalid", "banned"]) is True
- assert self._validate_none_of("banned", ["invalid", "banned"]) is False
-
-
-# --- Composite validation patterns ---
-
-
-class TestCompositeValidation:
- """Tests for composite validation patterns."""
-
- def _validate_all(self, value, validators):
- """All validators must pass."""
- for validator in validators:
- if not validator(value):
- return False
- return True
-
- def _validate_any(self, value, validators):
- """At least one validator must pass."""
- for validator in validators:
- if validator(value):
- return True
- return False
-
- def _validate_with_message(self, value, validators):
- """Run validators and collect error messages."""
- errors = []
- for name, validator in validators.items():
- if not validator(value):
- errors.append(name)
- return len(errors) == 0, errors
-
- def test_all_pass(self):
- validators = [lambda x: x > 0, lambda x: x < 100]
- assert self._validate_all(50, validators) is True
-
- def test_all_fail(self):
- validators = [lambda x: x > 0, lambda x: x < 100]
- assert self._validate_all(150, validators) is False
-
- def test_any_pass(self):
- validators = [lambda x: x == "a", lambda x: x == "b"]
- assert self._validate_any("b", validators) is True
-
- def test_any_fail(self):
- validators = [lambda x: x == "a", lambda x: x == "b"]
- assert self._validate_any("c", validators) is False
-
- def test_with_messages(self):
- validators = {
- "positive": lambda x: x > 0,
- "under_100": lambda x: x < 100,
- }
- valid, errors = self._validate_with_message(150, validators)
- assert valid is False
- assert "under_100" in errors
diff --git a/tests/news/test_web_blueprint_logic_behavior.py b/tests/news/test_web_blueprint_logic_behavior.py
deleted file mode 100644
index 58e70dd072..0000000000
--- a/tests/news/test_web_blueprint_logic_behavior.py
+++ /dev/null
@@ -1,375 +0,0 @@
-"""
-Deep behavioral tests for web.py pure logic.
-Tests default settings structure, load_user_settings patterns,
-health check response structure, and route context.
-"""
-
-
-# --- Default settings structure ---
-
-
-class TestDefaultSettingsStructure:
- """Tests for default settings dictionary structure."""
-
- def _get_default_settings(self):
- return {
- "iterations": 3,
- "questions_per_iteration": 5,
- "search_engine": "auto",
- "model_provider": "OLLAMA",
- "model": "",
- "search_strategy": "source-based",
- }
-
- def test_iterations_default(self):
- settings = self._get_default_settings()
- assert settings["iterations"] == 3
-
- def test_questions_per_iteration_default(self):
- settings = self._get_default_settings()
- assert settings["questions_per_iteration"] == 5
-
- def test_search_engine_default(self):
- settings = self._get_default_settings()
- assert settings["search_engine"] == "auto"
-
- def test_model_provider_default(self):
- settings = self._get_default_settings()
- assert settings["model_provider"] == "OLLAMA"
-
- def test_model_default_empty(self):
- settings = self._get_default_settings()
- assert settings["model"] == ""
-
- def test_search_strategy_default(self):
- settings = self._get_default_settings()
- assert settings["search_strategy"] == "source-based"
-
- def test_all_keys_present(self):
- settings = self._get_default_settings()
- expected_keys = {
- "iterations",
- "questions_per_iteration",
- "search_engine",
- "model_provider",
- "model",
- "search_strategy",
- }
- assert set(settings.keys()) == expected_keys
-
-
-# --- Load user settings update pattern ---
-
-
-class TestLoadUserSettingsUpdatePattern:
- """Tests for load_user_settings dictionary update."""
-
- def _load_user_settings(self, settings, values):
- settings.update(
- {
- "iterations": values.get("iterations", 3),
- "questions_per_iteration": values.get(
- "questions_per_iteration", 5
- ),
- "search_engine": values.get("search_engine", "auto"),
- "model_provider": values.get("model_provider", "OLLAMA"),
- "model": values.get("model", ""),
- "search_strategy": values.get(
- "search_strategy", "source-based"
- ),
- "custom_endpoint": values.get("custom_endpoint", ""),
- }
- )
-
- def test_updates_iterations(self):
- settings = {}
- self._load_user_settings(settings, {"iterations": 5})
- assert settings["iterations"] == 5
-
- def test_updates_model(self):
- settings = {}
- self._load_user_settings(settings, {"model": "gpt-4"})
- assert settings["model"] == "gpt-4"
-
- def test_adds_custom_endpoint(self):
- settings = {}
- self._load_user_settings(
- settings, {"custom_endpoint": "http://localhost"}
- )
- assert settings["custom_endpoint"] == "http://localhost"
-
- def test_preserves_defaults_for_missing(self):
- settings = {}
- self._load_user_settings(settings, {"iterations": 10})
- assert settings["model_provider"] == "OLLAMA"
- assert settings["search_engine"] == "auto"
-
-
-# --- Anonymous user check ---
-
-
-class TestAnonymousUserCheck:
- """Tests for anonymous user detection."""
-
- def _is_anonymous(self, username):
- return username == "anonymous"
-
- def test_anonymous_user(self):
- assert self._is_anonymous("anonymous") is True
-
- def test_regular_user(self):
- assert self._is_anonymous("alice") is False
-
- def test_empty_string(self):
- assert self._is_anonymous("") is False
-
- def test_none_username(self):
- # None != "anonymous"
- assert self._is_anonymous(None) is False
-
-
-class TestShouldLoadUserSettings:
- """Tests for condition to load user settings."""
-
- def _should_load_settings(self, username):
- return username != "anonymous"
-
- def test_load_for_real_user(self):
- assert self._should_load_settings("alice") is True
-
- def test_skip_for_anonymous(self):
- assert self._should_load_settings("anonymous") is False
-
-
-# --- Health check response structure ---
-
-
-class TestHealthCheckResponse:
- """Tests for health check response structures."""
-
- def _healthy_response(self):
- return {
- "status": "healthy",
- "enabled": True,
- "database": "connected",
- }
-
- def _unhealthy_response(self):
- return {
- "status": "unhealthy",
- "error": "An internal error has occurred.",
- }
-
- def test_healthy_status(self):
- response = self._healthy_response()
- assert response["status"] == "healthy"
-
- def test_healthy_enabled(self):
- response = self._healthy_response()
- assert response["enabled"] is True
-
- def test_healthy_database(self):
- response = self._healthy_response()
- assert response["database"] == "connected"
-
- def test_unhealthy_status(self):
- response = self._unhealthy_response()
- assert response["status"] == "unhealthy"
-
- def test_unhealthy_error_message(self):
- response = self._unhealthy_response()
- assert "error" in response
- # Should not leak internal details
- assert "internal" in response["error"].lower()
-
-
-# --- Subscription page context ---
-
-
-class TestSubscriptionPageContext:
- """Tests for subscription form page context."""
-
- def _build_new_subscription_context(self, default_settings):
- return {
- "subscription": None,
- "default_settings": default_settings,
- }
-
- def _build_edit_subscription_context(self, subscription, default_settings):
- return {
- "subscription": subscription,
- "default_settings": default_settings,
- }
-
- def test_new_has_none_subscription(self):
- ctx = self._build_new_subscription_context({})
- assert ctx["subscription"] is None
-
- def test_new_has_default_settings(self):
- settings = {"iterations": 3}
- ctx = self._build_new_subscription_context(settings)
- assert ctx["default_settings"]["iterations"] == 3
-
- def test_edit_has_subscription(self):
- sub = {"id": "sub-123", "name": "AI News"}
- ctx = self._build_edit_subscription_context(sub, {})
- assert ctx["subscription"]["id"] == "sub-123"
-
-
-class TestSubscriptionNotFoundContext:
- """Tests for subscription not found error context."""
-
- def _build_not_found_context(self, default_settings):
- return {
- "subscription": None,
- "error": "Subscription not found",
- "default_settings": default_settings,
- }
-
- def test_has_error_message(self):
- ctx = self._build_not_found_context({})
- assert ctx["error"] == "Subscription not found"
-
- def test_subscription_is_none(self):
- ctx = self._build_not_found_context({})
- assert ctx["subscription"] is None
-
-
-class TestSubscriptionErrorContext:
- """Tests for subscription load error context."""
-
- def _build_error_context(self, default_settings):
- return {
- "subscription": None,
- "error": "Error loading subscription",
- "default_settings": default_settings,
- }
-
- def test_has_generic_error(self):
- ctx = self._build_error_context({})
- assert "Error" in ctx["error"]
-
-
-# --- Session username extraction ---
-
-
-class TestSessionUsernameExtraction:
- """Tests for extracting username from session."""
-
- def _get_username(self, session):
- return session.get("username", "anonymous")
-
- def test_has_username(self):
- session = {"username": "alice"}
- assert self._get_username(session) == "alice"
-
- def test_missing_username_defaults_anonymous(self):
- session = {}
- assert self._get_username(session) == "anonymous"
-
- def test_none_session_key(self):
- session = {"username": None}
- # None is returned, not "anonymous" (get returns the value)
- assert self._get_username(session) is None
-
-
-# --- Settings manager key mapping ---
-
-
-class TestSettingsManagerKeyMapping:
- """Tests for settings key to manager key mapping."""
-
- KEY_MAP = {
- "iterations": "search.iterations",
- "questions_per_iteration": "search.questions_per_iteration",
- "search_engine": "search.tool",
- "model_provider": "llm.provider",
- "model": "llm.model",
- "search_strategy": "search.search_strategy",
- "custom_endpoint": "llm.openai_endpoint.url",
- }
-
- def test_iterations_key(self):
- assert self.KEY_MAP["iterations"] == "search.iterations"
-
- def test_search_engine_key(self):
- assert self.KEY_MAP["search_engine"] == "search.tool"
-
- def test_model_provider_key(self):
- assert self.KEY_MAP["model_provider"] == "llm.provider"
-
- def test_custom_endpoint_key(self):
- assert self.KEY_MAP["custom_endpoint"] == "llm.openai_endpoint.url"
-
-
-# --- Blueprint registration ---
-
-
-class TestBlueprintRoutes:
- """Tests for expected blueprint routes."""
-
- def _get_expected_routes(self):
- return [
- "/",
- "/subscriptions",
- "/subscriptions/new",
- "/subscriptions/<subscription_id>/edit",
- "/health",
- ]
-
- def test_has_main_route(self):
- assert "/" in self._get_expected_routes()
-
- def test_has_subscriptions_route(self):
- assert "/subscriptions" in self._get_expected_routes()
-
- def test_has_new_subscription_route(self):
- assert "/subscriptions/new" in self._get_expected_routes()
-
- def test_has_edit_subscription_route(self):
- routes = self._get_expected_routes()
- assert any("edit" in r for r in routes)
-
- def test_has_health_route(self):
- assert "/health" in self._get_expected_routes()
-
-
-# --- Template names ---
-
-
-class TestTemplateNames:
- """Tests for expected template names."""
-
- TEMPLATES = {
- "main": "pages/news.html",
- "subscriptions": "pages/subscriptions.html",
- "subscription_form": "pages/news-subscription-form.html",
- }
-
- def test_main_template(self):
- assert self.TEMPLATES["main"] == "pages/news.html"
-
- def test_subscriptions_template(self):
- assert self.TEMPLATES["subscriptions"] == "pages/subscriptions.html"
-
- def test_subscription_form_template(self):
- assert (
- self.TEMPLATES["subscription_form"]
- == "pages/news-subscription-form.html"
- )
-
-
-# --- Load user settings guard ---
-
-
-class TestLoadUserSettingsGuard:
- """Tests for load_user_settings guard conditions."""
-
- def _should_skip(self, db_session):
- return not db_session
-
- def test_skip_if_none(self):
- assert self._should_skip(None) is True
-
- def test_proceed_if_session(self):
- assert self._should_skip("mock_session") is False