732642856
1677 lines
62 KiB
Python
1677 lines
62 KiB
Python
#!/usr/bin/env python3
|
||
"""Security boundary tests for the lightweight Jyotish API server."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import base64
|
||
import json
|
||
import os
|
||
import sys
|
||
from io import BytesIO
|
||
from pathlib import Path
|
||
|
||
import pytest
|
||
|
||
SCRIPTS = os.path.join(os.path.dirname(__file__), '..', 'scripts')
|
||
if SCRIPTS not in sys.path:
|
||
sys.path.insert(0, SCRIPTS)
|
||
|
||
import jyotish_api_server # noqa: E402
|
||
from jyotish_api_server import ( # noqa: E402
|
||
DEFAULT_ALLOWED_ORIGINS,
|
||
BadRequest,
|
||
JyotishAPIHandler,
|
||
_load_local_module,
|
||
_parse_allowed_origins,
|
||
)
|
||
|
||
|
||
def _handler() -> JyotishAPIHandler:
|
||
return JyotishAPIHandler.__new__(JyotishAPIHandler)
|
||
|
||
|
||
class _FakeHeaders(dict):
|
||
def get(self, key, default=None):
|
||
return super().get(key, default)
|
||
|
||
|
||
class _FakeServer:
|
||
allowed_origins = DEFAULT_ALLOWED_ORIGINS
|
||
|
||
|
||
class _ResponseCaptureHandler(JyotishAPIHandler):
|
||
def __init__(self) -> None:
|
||
self.headers = _FakeHeaders()
|
||
self.server = _FakeServer()
|
||
self.path = '/api/capability_audit'
|
||
self.wfile = BytesIO()
|
||
self.status_code = None
|
||
self.response_headers = []
|
||
|
||
def send_response(self, code, message=None): # noqa: ANN001
|
||
self.status_code = code
|
||
|
||
def send_header(self, key, value): # noqa: ANN001
|
||
self.response_headers.append((key, value))
|
||
|
||
def end_headers(self):
|
||
return None
|
||
|
||
def _capability_audit(self):
|
||
raise RuntimeError('simulated internal failure')
|
||
|
||
def payload(self) -> dict:
|
||
return json.loads(self.wfile.getvalue().decode('utf-8'))
|
||
|
||
|
||
class _HealthCaptureHandler(JyotishAPIHandler):
|
||
def __init__(self) -> None:
|
||
self.headers = _FakeHeaders()
|
||
self.server = _FakeServer()
|
||
self.path = '/api/health'
|
||
self.wfile = BytesIO()
|
||
self.status_code = None
|
||
self.response_headers = []
|
||
|
||
def send_response(self, code, message=None): # noqa: ANN001
|
||
self.status_code = code
|
||
|
||
def send_header(self, key, value): # noqa: ANN001
|
||
self.response_headers.append((key, value))
|
||
|
||
def end_headers(self):
|
||
return None
|
||
|
||
def payload(self) -> dict:
|
||
return json.loads(self.wfile.getvalue().decode('utf-8'))
|
||
|
||
|
||
class _VedAstroStatusCaptureHandler(JyotishAPIHandler):
|
||
def __init__(self) -> None:
|
||
self.headers = _FakeHeaders()
|
||
self.server = _FakeServer()
|
||
self.path = '/api/vedastro/status'
|
||
self.wfile = BytesIO()
|
||
self.status_code = None
|
||
self.response_headers = []
|
||
|
||
def send_response(self, code, message=None): # noqa: ANN001
|
||
self.status_code = code
|
||
|
||
def send_header(self, key, value): # noqa: ANN001
|
||
self.response_headers.append((key, value))
|
||
|
||
def end_headers(self):
|
||
return None
|
||
|
||
def payload(self) -> dict:
|
||
return json.loads(self.wfile.getvalue().decode('utf-8'))
|
||
|
||
|
||
class _PostCaptureHandler(JyotishAPIHandler):
|
||
def __init__(self, path: str, payload: dict) -> None:
|
||
raw = json.dumps(payload).encode('utf-8')
|
||
self.headers = _FakeHeaders({'Content-Length': str(len(raw))})
|
||
self.server = _FakeServer()
|
||
self.path = path
|
||
self.rfile = BytesIO(raw)
|
||
self.wfile = BytesIO()
|
||
self.status_code = None
|
||
self.response_headers = []
|
||
|
||
def send_response(self, code, message=None): # noqa: ANN001
|
||
self.status_code = code
|
||
|
||
def send_header(self, key, value): # noqa: ANN001
|
||
self.response_headers.append((key, value))
|
||
|
||
def end_headers(self):
|
||
return None
|
||
|
||
def payload(self) -> dict:
|
||
return json.loads(self.wfile.getvalue().decode('utf-8'))
|
||
|
||
|
||
def test_default_cors_origins_are_local_only() -> None:
|
||
assert 'http://localhost:3456' in DEFAULT_ALLOWED_ORIGINS
|
||
assert '*' not in DEFAULT_ALLOWED_ORIGINS
|
||
assert 'https://example.com' not in DEFAULT_ALLOWED_ORIGINS
|
||
|
||
|
||
def test_env_cors_parser_ignores_empty_entries() -> None:
|
||
assert _parse_allowed_origins('https://app.example.com, ,http://localhost:3456') == {
|
||
'https://app.example.com',
|
||
'http://localhost:3456',
|
||
}
|
||
|
||
|
||
def test_get_internal_errors_are_json_wrapped() -> None:
|
||
handler = _ResponseCaptureHandler()
|
||
|
||
handler.do_GET()
|
||
|
||
assert handler.status_code == 500
|
||
assert ('Content-Type', 'application/json; charset=utf-8') in handler.response_headers
|
||
payload = handler.payload()
|
||
assert payload['success'] is False
|
||
assert payload['error'] == 'Internal server error'
|
||
assert payload['error_code'] == 'ERR_INTERNAL'
|
||
|
||
|
||
def test_health_endpoint_exposes_runtime_accuracy_metadata() -> None:
|
||
handler = _HealthCaptureHandler()
|
||
|
||
handler.do_GET()
|
||
|
||
assert handler.status_code == 200
|
||
payload = handler.payload()
|
||
assert payload['status'] == 'ok'
|
||
assert payload['ayanamsa_default'] == 'lahiri'
|
||
assert 'swisseph_available' in payload
|
||
assert 'swisseph_version' in payload
|
||
|
||
|
||
def test_vedastro_status_endpoint_exposes_safe_adapter_state(monkeypatch) -> None:
|
||
monkeypatch.setenv('VEDASTRO_API_ENDPOINT', 'https://vedastro.example.test/secret/path')
|
||
monkeypatch.delenv('VEDASTRO_ENABLE_NETWORK', raising=False)
|
||
handler = _VedAstroStatusCaptureHandler()
|
||
|
||
handler.do_GET()
|
||
|
||
assert handler.status_code == 200
|
||
payload = handler.payload()
|
||
assert payload['adapter'] == 'vedastro_service_adapter'
|
||
assert payload['configured'] is True
|
||
assert payload['network_enabled'] is False
|
||
assert payload['status'] == 'network_execution_disabled'
|
||
assert payload['endpoint_host'] == 'vedastro.example.test'
|
||
assert 'secret/path' not in json.dumps(payload)
|
||
assert payload['required_env']['endpoint'] == 'VEDASTRO_API_ENDPOINT'
|
||
assert payload['live_profile'] == 'vedastro-live'
|
||
|
||
|
||
def test_vedastro_status_endpoint_honors_explicit_network_disable_even_when_local_env_exists(monkeypatch) -> None:
|
||
monkeypatch.setenv('VEDASTRO_API_ENDPOINT', 'https://vedastro.example.test/secret/path')
|
||
monkeypatch.setenv('VEDASTRO_ENABLE_NETWORK', '0')
|
||
handler = _VedAstroStatusCaptureHandler()
|
||
|
||
handler.do_GET()
|
||
|
||
payload = handler.payload()
|
||
assert payload['network_enabled'] is False
|
||
assert payload['status'] == 'network_execution_disabled'
|
||
|
||
|
||
def test_vedastro_range_scan_endpoint_uses_user_birth_and_returns_controlled_blocked_state(monkeypatch) -> None:
|
||
monkeypatch.delenv('VEDASTRO_API_ENDPOINT', raising=False)
|
||
monkeypatch.delenv('VEDASTRO_ENABLE_NETWORK', raising=False)
|
||
handler = _PostCaptureHandler('/api/vedastro/range_scan', {
|
||
'domain': 'relationship',
|
||
'start_date': '2026-01-01',
|
||
'end_date': '2026-12-31',
|
||
'year': REDACTED_YEAR,
|
||
'month': 4,
|
||
'day': 17,
|
||
'hour': 14,
|
||
'minute': 49,
|
||
'second': 0,
|
||
'lat': 36.4467,
|
||
'lon': 114.2,
|
||
'tz': 8,
|
||
'ayanamsa_policy': 'lahiri',
|
||
'node_policy': 'mean',
|
||
})
|
||
|
||
handler.do_POST()
|
||
|
||
assert handler.status_code == 200
|
||
payload = handler.payload()
|
||
assert payload['success'] is True
|
||
assert payload['endpoint'] == 'vedastro_range_scan'
|
||
assert payload['ui_domain'] == 'relationship'
|
||
assert payload['adapter_domain'] == 'marriage'
|
||
assert payload['result']['status'] == 'service_endpoint_not_configured'
|
||
assert payload['result']['operation'] == 'range_scan'
|
||
assert payload['result']['request_preview']['year'] == REDACTED_YEAR
|
||
assert payload['result']['request_preview']['lat'] == 36.4467
|
||
assert payload['result']['request_preview']['domain'] == 'marriage'
|
||
assert payload['boundary'] == 'VedAstro range scan is optional external timing evidence; local Jyotish gates remain authoritative.'
|
||
|
||
|
||
@pytest.mark.parametrize(
|
||
('key', 'value', 'minimum', 'maximum'),
|
||
[
|
||
('lat', 91, -90, 90),
|
||
('lon', 181, -180, 180),
|
||
('tz', 15, -14, 14),
|
||
('minute', 60, 0, 59),
|
||
],
|
||
)
|
||
def test_numeric_bounds_reject_invalid_values(key, value, minimum, maximum) -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest):
|
||
handler._get_float({key: value}, key, 0, minimum, maximum)
|
||
|
||
|
||
def test_chart_date_validation_rejects_impossible_date() -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest, match='Invalid birth date'):
|
||
handler._compute_chart({'year': 2026, 'month': 2, 'day': 31})
|
||
|
||
|
||
def test_synastry_rejects_non_numeric_moon_degree() -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest, match='male_moon must be a number'):
|
||
handler._compute_synastry({'male_moon': 'not-a-number', 'female_moon': 120})
|
||
|
||
|
||
def test_synastry_normalizes_360_degree_boundary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_synastry({'male_moon': 360, 'female_moon': 0})
|
||
assert result['male_details']['nakshatra'] == result['female_details']['nakshatra']
|
||
assert result['max_score'] == 36.0
|
||
|
||
|
||
def test_synastry_api_uses_full_ashtakoot_engine() -> None:
|
||
from ashtakoot import calculate_ashtakoot
|
||
|
||
handler = _handler()
|
||
api_result = handler._compute_synastry({'male_moon': 0, 'female_moon': 60})
|
||
engine_result = calculate_ashtakoot(0, 60)
|
||
|
||
assert api_result['method'] == engine_result['method']
|
||
assert api_result['scores'] == engine_result['scores']
|
||
assert api_result['total_score'] == engine_result['total_score']
|
||
assert api_result['is_match_approved'] == engine_result['is_match_approved']
|
||
assert api_result['scores']['Vashya'] == 0.5
|
||
assert 'BadConstellations' in api_result['additional_kutas']
|
||
|
||
|
||
def test_prashna_rejects_non_string_question() -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest, match='question must be a string'):
|
||
handler._compute_prashna({'question': {'bad': 'shape'}, 'planets': {}})
|
||
|
||
|
||
def test_prashna_returns_chart_and_answer_for_valid_request() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_prashna({
|
||
'question': 'career',
|
||
'question_text': '这个工作机会是否值得争取？',
|
||
'horary_number': 140,
|
||
'planets': {'Saturn': {'sign': 'Pisces'}, 'Moon': {'sign': 'Scorpio'}},
|
||
})
|
||
assert 'prashna_chart' in result
|
||
assert 'kp_answer' in result
|
||
assert result['kp_answer']['question_type'] == 'career'
|
||
assert result['kp_answer_v2']['primary_house'] == 10
|
||
assert 'arudha' in result
|
||
assert 'sphutas' in result
|
||
assert 'sahams' in result
|
||
assert 'lost_item' in result
|
||
assert 'kunda' in result
|
||
kp_horary = result['kp_horary']
|
||
assert kp_horary['method'] == 'KP Horary'
|
||
assert kp_horary['horary_number'] == 140
|
||
assert kp_horary['question_houses']['primary'] == 10
|
||
assert kp_horary['ruling_planets']['ascendant_lord']
|
||
assert kp_horary['ruling_planets']['moon_star_lord']
|
||
assert kp_horary['cuspal_sub_lord']['house'] == 10
|
||
assert kp_horary['cuspal_sub_lord']['kp_lords']['sub_lord']
|
||
assert kp_horary['house_significators']['10']
|
||
assert kp_horary['judgement_matrix']
|
||
|
||
|
||
def test_prashna_advanced_legacy_functions_exist() -> None:
|
||
import prashna
|
||
|
||
planet_lons = {
|
||
'Sun': 10,
|
||
'Moon': 70,
|
||
'Mars': 120,
|
||
'Mercury': 25,
|
||
'Jupiter': 150,
|
||
'Venus': 45,
|
||
'Saturn': 210,
|
||
'Rahu': 300,
|
||
'Ketu': 120,
|
||
}
|
||
assert prashna.cast_prashna('2026-06-22 12:00', 28.6, 77.2)['ascendant']
|
||
assert prashna.calc_arudha(15.5, planet_lons)['arudha_house']
|
||
assert prashna.calc_sphutas(planet_lons, 15.5)['trisphuta']
|
||
assert prashna.calc_life_sphutas(15.5, 70, 10)['signal']
|
||
assert prashna.calc_sahams(planet_lons, 15.5)['count'] >= 5
|
||
assert prashna.analyze_lost_item(planet_lons, 15.5)['summary']
|
||
assert prashna.kunda_verify(15.5)['nakshatra']
|
||
|
||
|
||
def test_dasha_system_rejects_unknown_key() -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest, match='Unknown dasha system'):
|
||
handler._compute_dasha_system({'dasha': 'not-a-dasha'})
|
||
|
||
|
||
def test_dasha_system_returns_periods_for_valid_request() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_dasha_system({
|
||
'dasha': 'yogini',
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'planets': {'Moon': {'lon': 120}, 'Sun': {'lon': 80}},
|
||
'ascendant': {'sign_idx': 0},
|
||
})
|
||
assert result['success'] is True
|
||
assert result['key'] == 'yogini'
|
||
assert result['precision'] == 'calculator'
|
||
assert result['periods']
|
||
assert result['periods'][0]['lord'] in {
|
||
'Mangala',
|
||
'Pingala',
|
||
'Dhanya',
|
||
'Bhramari',
|
||
'Bhadrika',
|
||
'Ulka',
|
||
'Siddha',
|
||
'Sankata',
|
||
}
|
||
assert {'lord', 'start', 'end', 'years'} <= set(result['periods'][0])
|
||
assert 'vimshottari_analysis' not in result
|
||
|
||
|
||
def test_vimshottari_dasha_reuses_analyzer_fragment() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_dasha_system({
|
||
'dasha': 'vimshottari',
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'today': '2026-06-23',
|
||
'planets': {'Moon': {'lon': 123}, 'Sun': {'lon': 80}},
|
||
'ascendant': {'sign_idx': 0},
|
||
})
|
||
|
||
analysis = result['vimshottari_analysis']
|
||
assert result['success'] is True
|
||
assert 'dasha_analyzer.py' in result['fragment_sources']
|
||
assert analysis['source'] == 'dasha_analyzer.py + dasha_calculator_enhanced.py'
|
||
assert analysis['nakshatra']['name']
|
||
assert analysis['current']['mahadasha']['lord']
|
||
assert analysis['current']['antardasha']['lord']
|
||
assert analysis['five_levels']['mahadasha']['lord'] == analysis['current']['mahadasha']['lord']
|
||
assert analysis['summary']['headline'].startswith('当前处于')
|
||
|
||
|
||
def test_relationship_returns_spouse_status_fragment() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_relationship({
|
||
'asc_sign': 'Cancer',
|
||
'planets': {
|
||
'Sun': {'sign': 'Leo', 'degree': 20, 'house': 2, 'dignity': 'own'},
|
||
'Moon': {'sign': 'Cancer', 'degree': 12, 'house': 1, 'dignity': 'own'},
|
||
'Mars': {'sign': 'Sagittarius', 'degree': 26, 'house': 6, 'dignity': 'friendly'},
|
||
'Mercury': {'sign': 'Virgo', 'degree': 8, 'house': 3, 'dignity': 'own'},
|
||
'Jupiter': {'sign': 'Pisces', 'degree': 14, 'house': 9, 'dignity': 'own'},
|
||
'Venus': {'sign': 'Taurus', 'degree': 2, 'house': 11, 'dignity': 'own'},
|
||
'Saturn': {'sign': 'Capricorn', 'degree': 28, 'house': 7, 'dignity': 'own'},
|
||
'Rahu': {'sign': 'Gemini', 'degree': 18, 'house': 12},
|
||
'Ketu': {'sign': 'Sagittarius', 'degree': 18, 'house': 6},
|
||
},
|
||
'dasha_info': {'maha_dasha': 'Venus', 'antar_dasha': 'Jupiter'},
|
||
})
|
||
assert 'spouse_status_yoga' in result
|
||
assert result['spouse_status_yoga']['principles']
|
||
assert 'spouse_status_yoga.py' in result['fragment_sources']
|
||
assert result['spouse_status_yoga']['overall_score'] >= 0
|
||
assert 'relationship_timing' in result
|
||
assert 'darakaraka_reader.py' in result['fragment_sources']
|
||
assert 'jaimini.py' in result['fragment_sources']
|
||
assert result['relationship_timing']['darakaraka']['dk_planet']
|
||
assert result['relationship_timing']['upapada']['sign']
|
||
assert result['relationship_timing']['dasha_focus']['hits']
|
||
assert result['relationship_timing']['evidence']
|
||
|
||
|
||
def test_chart_returns_remedies_with_shadbala_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_chart({
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 39.9,
|
||
'lon': 116.4,
|
||
'tz': 8,
|
||
})
|
||
assert 'remedies' in result
|
||
assert 'summary' in result['remedies']
|
||
assert 'recommendations' in result['remedies']
|
||
|
||
|
||
def test_chart_returns_sunrise_correct_special_lagnas() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_chart({
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 10,
|
||
'minute': 30,
|
||
'lat': 28.6,
|
||
'lon': 77.2,
|
||
'tz': 5.5,
|
||
})
|
||
special = result['special_lagnas']
|
||
assert special['capability_status'] == 'covered'
|
||
assert special['precision'] == 'sunrise_correct'
|
||
assert 'sunrise_local_time' in special
|
||
assert 'ghatis_elapsed_from_sunrise' in special
|
||
assert all(key in special for key in ('HL', 'GL', 'VL'))
|
||
|
||
|
||
def test_remedies_accepts_api_rupas_shape() -> None:
|
||
remedies = _load_local_module('remedies')
|
||
|
||
result = remedies.recommend_remedies({'Sun': {'rupas': 0.4, 'level': '弱'}})
|
||
assert result['weak_planets'] == ['Sun']
|
||
assert result['recommendations']['mantras']
|
||
|
||
|
||
def test_remedies_endpoint_accepts_numeric_shadbala_shorthand() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_remedies({
|
||
'shadbala': {'Sun': 0.42, 'Moon': 0.68},
|
||
'dasha_lord': 'Saturn',
|
||
'doshas': ['Mangal Dosha'],
|
||
})
|
||
|
||
assert result['weak_planets'] == ['Sun']
|
||
assert 'Moon' in result['moderate_planets']
|
||
assert any(item['source'] == 'shadbala' and item['planet'] == 'Sun' for item in result['evidence_chain'])
|
||
|
||
|
||
def test_import_chart_accepts_plain_text() -> None:
|
||
handler = _handler()
|
||
result = handler._import_chart_text({
|
||
'text': 'Date of Birth: 1990-06-15\nTime of Birth: 12:30\nPlace of Birth: Delhi\nTimezone: UTC+5:30',
|
||
})
|
||
assert result['success'] is True
|
||
assert result['extractor'] == 'text'
|
||
assert '1990-06-15' in result['text']
|
||
|
||
|
||
def test_import_chart_accepts_base64_text_file() -> None:
|
||
handler = _handler()
|
||
content = base64.b64encode(b'DOB: 1990-06-15\nTOB: 12:30\nCity: Mumbai').decode()
|
||
result = handler._import_chart_text({'filename': 'chart.txt', 'content_base64': content})
|
||
assert result['success'] is True
|
||
assert result['extractor'] == 'text'
|
||
assert 'Mumbai' in result['text']
|
||
|
||
|
||
def test_import_chart_requires_input() -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest, match='text or content_base64 is required'):
|
||
handler._import_chart_text({})
|
||
|
||
|
||
def test_import_chart_rejects_bad_base64() -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest, match='Invalid base64 content'):
|
||
handler._import_chart_text({'filename': 'chart.txt', 'content_base64': 'not-base64!'})
|
||
|
||
|
||
def test_import_chart_rejects_oversized_file() -> None:
|
||
handler = _handler()
|
||
content = base64.b64encode(b'x' * (1536 * 1024 + 1)).decode()
|
||
with pytest.raises(BadRequest, match='Import file too large'):
|
||
handler._import_chart_text({'filename': 'chart.txt', 'content_base64': content})
|
||
|
||
|
||
def test_report_artifact_generates_html_fallback_artifact() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'client report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'report_artifact'
|
||
assert result['format'] == 'html'
|
||
assert result['html_filename'].endswith('.html')
|
||
assert result['html_base64']
|
||
assert os.path.exists(result['html_path'])
|
||
assert result['artifact_status'] == 'html_ready'
|
||
assert result['primary_artifact'] == 'html'
|
||
assert result['download_filename'] == result['html_filename']
|
||
assert result['download_mime'] == 'text/html;charset=utf-8'
|
||
assert result['fallback_reason'] is None
|
||
assert result['user_message']
|
||
assert result['next_action']
|
||
assert result['delivery']['format'] == 'html'
|
||
assert result['delivery']['filename'] == result['html_filename']
|
||
assert result['delivery']['artifact_status'] == 'html_ready'
|
||
assert result['delivery']['user_message']
|
||
assert result['delivery']['next_action']
|
||
|
||
|
||
def test_report_artifact_can_render_functional_benefic_malefic_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'functional-role-report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
'functional_benefic_malefic': {
|
||
'status': 'used',
|
||
'ascendant': 'Leo',
|
||
'functional_benefics': ['Sun', 'Mars', 'Jupiter'],
|
||
'functional_malefics': ['Venus', 'Saturn'],
|
||
'functional_neutrals': ['Mercury'],
|
||
'yogakarakas': ['Mars'],
|
||
'effect_on_confidence': '高严谨模式下必须叠加功能性吉凶星。',
|
||
},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
html = Path(result['html_path']).read_text(encoding='utf-8')
|
||
assert 'Functional Benefic/Malefic' in html
|
||
assert 'Leo' in html
|
||
assert 'Sun, Mars, Jupiter' in html
|
||
assert 'Venus, Saturn' in html
|
||
assert 'Mercury' in html
|
||
assert 'Mars' in html
|
||
assert 'Yogakarakas' in html
|
||
assert 'Functional Neutrals' in html
|
||
assert '高严谨模式下必须叠加功能性吉凶星。' in html
|
||
|
||
|
||
def test_report_artifact_can_render_vimsopaka_semantic_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'vimsopaka-semantic-report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
'vimsopaka_semantic_summary': {
|
||
'status': 'used',
|
||
'highlights': ['Sun: 极友(Great Friend)', 'Moon: 落陷取消(Neecha Bhanga)'],
|
||
'warnings': ['Mars: 极敌(Great Enemy)'],
|
||
},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
html = Path(result['html_path']).read_text(encoding='utf-8')
|
||
assert 'Vimsopaka Semantic Summary' in html
|
||
assert 'Great Friend' in html
|
||
assert 'Neecha Bhanga' in html
|
||
assert 'Great Enemy' in html
|
||
|
||
|
||
def test_report_artifact_can_render_vedastro_external_overview() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'vedastro-overview-report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
'vedastro_overview': {
|
||
'status': 'ok',
|
||
'source': 'vedastro_service_adapter_candidate',
|
||
'ingestion_profile': 'main_entry_overview',
|
||
'search_scope': 'single_day_overview',
|
||
'reference_date': '2026-06-29',
|
||
'event_count': 5,
|
||
'domain_statuses': {'career': 'ok', 'marriage': 'ok', 'wealth': 'ok'},
|
||
'top_events_by_domain': {
|
||
'marriage': {'signal_label': 'Jupiter in 7th marriage window', 'start': '2026-06-29'},
|
||
'career': {'signal_label': 'Jupiter in 10th career window', 'start': '2026-06-29'},
|
||
},
|
||
'boundary_note': 'This is overview only and does not replace explicit long-range scans.',
|
||
},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
html = Path(result['html_path']).read_text(encoding='utf-8')
|
||
assert 'VedAstro External Overview' in html
|
||
assert 'main_entry_overview' in html
|
||
assert 'single_day_overview' in html
|
||
assert '2026-06-29' in html
|
||
assert 'Jupiter in 7th marriage window' in html
|
||
assert 'overview only' in html
|
||
|
||
|
||
def test_report_artifact_can_render_relationship_strict_narrative_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'relationship-strict-report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
'relationship_narrative': {
|
||
'headline': '婚恋严格裁决已接入 synastry taxonomy，可把合盘支持翻译成次级关系语义。',
|
||
'strengths': ['合盘支持已进入婚恋主链，但它只说明关系兼容度有帮助。'],
|
||
'risks': ['当前 confidence cap 偏低，dual dasha / external timing / marriage convergence 存在冲突或不足。'],
|
||
'boundaries': ['婚恋高严谨模式至少需要 D1、D9、UL、Vimshottari 与 Narayana dual dasha 同时在场。'],
|
||
},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
html = Path(result['html_path']).read_text(encoding='utf-8')
|
||
assert 'Relationship Strict Narrative' in html
|
||
assert 'synastry taxonomy' in html
|
||
assert 'dual dasha' in html
|
||
assert 'D1、D9、UL' in html
|
||
|
||
|
||
def test_report_artifact_relationship_strict_narrative_keeps_conflict_downgrade_language() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'relationship-strict-conflict-report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
'relationship_narrative': {
|
||
'headline': '婚恋 strict workflow 已识别支持层，但 timing conflict 仍要求降置信度。',
|
||
'strengths': ['D9、UL 与部分 synastry taxonomy 已在场。'],
|
||
'risks': ['dual dasha 与 external timing 发生冲突，不能把窗口直接抬成 legal marriage。'],
|
||
'boundaries': ['存在 timing conflict 时，最终婚恋 narrative 必须明确降置信度。'],
|
||
'markdown': '### 婚恋严格裁决\n- 当前 dual dasha 与 external timing 存在冲突，必须降置信度，不能把 supportive kuta 直接提升为 legal marriage。\n',
|
||
},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
html = Path(result['html_path']).read_text(encoding='utf-8')
|
||
assert 'timing conflict' in html
|
||
assert 'dual dasha' in html
|
||
assert '降置信度' in html
|
||
|
||
|
||
def test_report_artifact_relationship_strict_narrative_surfaces_public_formalization_candidate_boundary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'relationship-strict-public-formalization-report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
'relationship_narrative': {
|
||
'headline': '当前关系更接近 public_formalization candidate，而不是 legal marriage。',
|
||
'strengths': ['公开化/可见度支持正在升温，但仍属于 context-only 线索。'],
|
||
'risks': ['dual dasha 与 marriage convergence 还不足以把事件抬升为法律婚姻。'],
|
||
'boundaries': ['public_formalization_candidate 只表示公开化候选，不等于法律婚姻，不能越权替代 legal_marriage。'],
|
||
'markdown': '### 婚恋严格裁决\n- public_formalization_candidate 已进入 secondary-context，但仍不能替代 legal_marriage。\n',
|
||
},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
html = Path(result['html_path']).read_text(encoding='utf-8')
|
||
assert 'public_formalization_candidate' in html
|
||
assert '不等于法律婚姻' in html
|
||
assert 'legal_marriage' in html
|
||
|
||
|
||
def test_report_artifact_relationship_strict_narrative_warns_public_formalization_candidate_not_to_be_misread_as_near_marriage() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'relationship-strict-public-formalization-conflict-report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
'relationship_narrative': {
|
||
'headline': '当前更接近 public_formalization candidate，但 timing conflict 仍然存在。',
|
||
'strengths': ['公开化候选正在形成，但仍只是 context-only 层。'],
|
||
'risks': ['当前 dual dasha / external timing 仍有冲突，不能误读成接近结婚。'],
|
||
'boundaries': ['public_formalization_candidate 不等于法律婚姻，不能越权替代 legal_marriage。'],
|
||
'markdown': '### 婚恋严格裁决\n- public_formalization_candidate 已进入 secondary-context，但当前 dual dasha 与 external timing 仍有冲突，不能误读成接近结婚，也不能替代 legal_marriage。\n',
|
||
},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
html = Path(result['html_path']).read_text(encoding='utf-8')
|
||
assert 'public_formalization_candidate' in html
|
||
assert '不能误读成接近结婚' in html
|
||
assert 'legal_marriage' in html
|
||
|
||
|
||
def test_report_artifact_relationship_strict_narrative_surfaces_weak_core_promise_guardrail_for_public_formalization_candidate() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'html',
|
||
'name': 'relationship-strict-weak-core-promise-report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish</h1></body></html>',
|
||
'relationship_narrative': {
|
||
'headline': '当前更接近 public_formalization candidate，但 core marriage promise 仍偏弱。',
|
||
'strengths': [
|
||
'合盘支持已进入婚恋主链，但它只说明关系兼容度有帮助。',
|
||
'公开化/关系可见度候选正在增强，但仍未达到法律婚姻落地。',
|
||
],
|
||
'risks': ['当前 core marriage promise 偏弱，不能误读成接近结婚。'],
|
||
'boundaries': [
|
||
'protective kuta support 只能辅助，不得越权抬升 legal_marriage。',
|
||
'public_formalization_candidate 不等于法律婚姻。',
|
||
],
|
||
'markdown': '### 婚恋严格裁决\n- public_formalization_candidate 与 synastry_support 可以同时存在，但在 weak core marriage promise 下，仍不能写成婚姻逼近，也不能替代 legal_marriage。\n',
|
||
},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
html = Path(result['html_path']).read_text(encoding='utf-8')
|
||
assert 'public_formalization_candidate' in html
|
||
assert '合盘支持已进入婚恋主链' in html
|
||
assert '不能误读成接近结婚' in html
|
||
assert 'legal_marriage' in html
|
||
assert 'relationship-caution' in html
|
||
|
||
|
||
def test_report_artifact_pdf_fallback_exposes_user_visible_delivery(monkeypatch) -> None:
|
||
class BrokenReportBuilder:
|
||
@staticmethod
|
||
def _html_to_pdf(_html_path, _pdf_path):
|
||
return False
|
||
|
||
def fake_load_local_module(name):
|
||
if name == 'report_builder':
|
||
return BrokenReportBuilder
|
||
return _load_local_module(name)
|
||
|
||
monkeypatch.setattr(jyotish_api_server, '_load_local_module', fake_load_local_module)
|
||
handler = _handler()
|
||
result = handler._compute_report_artifact({
|
||
'format': 'pdf',
|
||
'name': '../client pdf report',
|
||
'html': '<!doctype html><html><body><h1>Jyotish PDF</h1></body></html>',
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['format'] == 'pdf'
|
||
assert result['fallback'] == 'html'
|
||
assert result['artifact_status'] == 'pdf_fallback_html_ready'
|
||
assert result['primary_artifact'] == 'html'
|
||
assert result['download_filename'] == result['html_filename']
|
||
assert result['download_mime'] == 'text/html;charset=utf-8'
|
||
assert result['download_filename'].endswith('.html')
|
||
assert '/' not in result['download_filename']
|
||
assert result['fallback_reason']
|
||
assert 'PDF renderer unavailable' in result['message']
|
||
assert 'HTML' in result['user_message']
|
||
assert 'PDF' in result['user_message']
|
||
assert result['delivery']['fallback'] is True
|
||
assert result['delivery']['artifact_status'] == 'pdf_fallback_html_ready'
|
||
assert result['delivery']['filename'] == result['download_filename']
|
||
assert result['delivery']['fallback_reason'] == result['fallback_reason']
|
||
assert result['delivery']['user_message'] == result['user_message']
|
||
|
||
|
||
@pytest.mark.parametrize(
|
||
'html',
|
||
[
|
||
'<script>alert(1)</script>',
|
||
'<img src=x onerror="alert(1)">',
|
||
'<a href="javascript:alert(1)">x</a>',
|
||
],
|
||
)
|
||
def test_report_artifact_rejects_active_html(html: str) -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest, match='active content'):
|
||
handler._compute_report_artifact({'format': 'html', 'html': html})
|
||
|
||
|
||
def test_oracle_evidence_api_validates_uploaded_packets() -> None:
|
||
handler = _handler()
|
||
draft_packet = {
|
||
'case_id': 'template_user_REDACTED_YEAR_moon_longitude_lahiri',
|
||
'status': 'draft',
|
||
'evidence_packet': {
|
||
'status': 'draft',
|
||
'metadata': {
|
||
'tool_name': '',
|
||
'tool_version_or_url': '',
|
||
'capture_date': '',
|
||
'source_artifact': '',
|
||
'ayanamsa': '',
|
||
'node_mode': '',
|
||
'timezone': '',
|
||
'operator_note': '',
|
||
},
|
||
},
|
||
'target': {
|
||
'moon_sidereal_longitude_deg': None,
|
||
'vimshottari_start_date': None,
|
||
'shadbala_components': {},
|
||
},
|
||
}
|
||
|
||
draft_result = handler._compute_oracle_evidence({'packet': draft_packet})
|
||
|
||
assert draft_result['success'] is True
|
||
assert draft_result['endpoint'] == 'oracle_evidence'
|
||
assert draft_result['report']['summary']['valid_packets'] == 0
|
||
assert draft_result['report']['summary']['ready_for_calibration'] == 0
|
||
assert draft_result['report']['summary']['production_tuning_allowed'] is False
|
||
first = draft_result['report']['packets'][0]
|
||
assert first['valid'] is False
|
||
assert 'missing_metadata:tool_name' in first['problems']
|
||
assert 'missing_external_artifact' in first['problems']
|
||
assert 'status_not_external_verified:draft' in first['problems']
|
||
|
||
filled_packet = {
|
||
**draft_packet,
|
||
'status': 'external_verified',
|
||
'evidence_packet': {
|
||
'status': 'external_verified',
|
||
'metadata': {
|
||
'tool_name': 'Local Engine',
|
||
'tool_version_or_url': 'this-repo',
|
||
'capture_date': '2026-06-25',
|
||
'source_artifact': 'scripts/jyotish_engine.py output',
|
||
'ayanamsa': 'lahiri',
|
||
'node_mode': 'mean',
|
||
'timezone': 'UTC+08:00',
|
||
'operator_note': 'Local run',
|
||
},
|
||
},
|
||
'target': {
|
||
'moon_sidereal_longitude_deg': 311.7897,
|
||
'vimshottari_start_date': '1986-05-18',
|
||
'shadbala_components': {
|
||
'Sun': {
|
||
'sthana': 100.0,
|
||
'dig': 50.0,
|
||
'kala': 100.0,
|
||
'chesta': 40.0,
|
||
'naisargika': 60.0,
|
||
'drik': 30.0,
|
||
},
|
||
},
|
||
},
|
||
}
|
||
|
||
local_result = handler._compute_oracle_evidence({'packet': filled_packet})
|
||
|
||
local_first = local_result['report']['packets'][0]
|
||
assert local_first['valid'] is False
|
||
assert 'local_engine_artifact_rejected' in local_first['problems']
|
||
|
||
|
||
def test_capability_audit_scans_registry_and_local_sources() -> None:
|
||
handler = _handler()
|
||
audit = handler._capability_audit()
|
||
|
||
assert audit['success'] is True
|
||
assert audit['registry']['technique_count'] >= 60
|
||
assert audit['surfaces']['engine_command_count'] >= 30
|
||
assert '/api/chart' in audit['surfaces']['api_endpoints']
|
||
assert '/api/tajika' in audit['surfaces']['api_endpoints']
|
||
assert 'varga-full' not in audit['surfaces']['engine_not_api']
|
||
assert 'jaimini' not in audit['surfaces']['engine_not_api']
|
||
assert 'ashtakavarga' not in audit['surfaces']['engine_not_api']
|
||
assert 'shadbala' not in audit['surfaces']['engine_not_api']
|
||
assert 'yoga' not in audit['surfaces']['engine_not_api']
|
||
assert 'aspects' not in audit['surfaces']['engine_not_api']
|
||
assert 'muhurta' not in audit['surfaces']['engine_not_api']
|
||
assert audit['local_open_source']['source_count'] >= 3
|
||
assert any(source['name'] == 'dashaflow' for source in audit['local_open_source']['sources'])
|
||
assert all(gap.get('command') != 'varga-full' for gap in audit['priority_gaps'])
|
||
assert 'Muhurta' in audit['surfaces']['app_visible_topics']
|
||
assert 'Tajika' in audit['surfaces']['app_visible_topics']
|
||
assert 'Bhava Chalit' in audit['surfaces']['app_visible_topics']
|
||
assert 'Sudarshana' in audit['surfaces']['app_visible_topics']
|
||
assert 'Jaimini' in audit['surfaces']['app_visible_topics']
|
||
assert 'Ashtakavarga' in audit['surfaces']['app_visible_topics']
|
||
assert 'Shadbala' in audit['surfaces']['app_visible_topics']
|
||
assert 'Yoga' in audit['surfaces']['app_visible_topics']
|
||
assert 'Aspects' in audit['surfaces']['app_visible_topics']
|
||
assert 'Birth Rectification' in audit['surfaces']['app_visible_topics']
|
||
assert 'Case Validation' in audit['surfaces']['app_visible_topics']
|
||
assert 'Divisional Yoga' in audit['surfaces']['app_visible_topics']
|
||
assert 'Kakshya' in audit['surfaces']['app_visible_topics']
|
||
assert '/api/deep_varga_avastha' in audit['surfaces']['api_endpoints']
|
||
assert all(gap['kind'] != 'app_visibility' for gap in audit['priority_gaps'])
|
||
productization = audit['productization']
|
||
summary = productization['summary']
|
||
assert sum(summary.values()) == audit['registry']['technique_count']
|
||
assert summary['productized'] > 0
|
||
assert productization['rows']
|
||
assert all('next_action' in row for row in productization['rows'])
|
||
ux = audit['ux_productization']
|
||
assert set(ux['criteria']) == {
|
||
'clear_entry',
|
||
'human_readable_conclusion',
|
||
'evidence_chain',
|
||
'next_action',
|
||
'json_hidden',
|
||
'mobile_scannable',
|
||
}
|
||
assert sum(ux['summary'].values()) == audit['registry']['technique_count']
|
||
assert ux['rows']
|
||
assert ux['summary']['excellent'] == audit['registry']['technique_count']
|
||
assert ux['summary']['usable'] == 0
|
||
assert ux['summary']['thin'] == 0
|
||
assert ux['summary']['not_user_ready'] == 0
|
||
assert all(0 <= row['ux_score'] <= 6 for row in ux['rows'])
|
||
assert all('ux_next_action' in row for row in ux['next_queue'])
|
||
ux_by_id = {row['id']: row for row in ux['rows']}
|
||
assert ux_by_id['birth_time_rectifier']['ux_level'] in {'excellent', 'usable'}
|
||
assert ux_by_id['case_validator']['ux_level'] in {'excellent', 'usable'}
|
||
assert ux_by_id['divisional_yoga']['ux_level'] in {'excellent', 'usable'}
|
||
assert ux_by_id['deep_varga_avastha']['ux_level'] in {'excellent', 'usable'}
|
||
assert ux_by_id['kakshya']['ux_level'] in {'excellent', 'usable'}
|
||
for technique_id in ['ashtakavarga_pav', 'ashtakavarga_sodhita', 'remedies']:
|
||
assert ux_by_id[technique_id]['ux_level'] == 'excellent'
|
||
for technique_id in ['bhava_bala', 'career_engine', 'kp_system', 'prashna', 'synastry_16factor', 'transit_trigger']:
|
||
assert ux_by_id[technique_id]['ux_level'] in {'excellent', 'usable'}
|
||
|
||
|
||
def test_technique_catalog_exposes_runnable_api_examples() -> None:
|
||
handler = _handler()
|
||
catalog = handler._technique_catalog()
|
||
|
||
assert catalog['success'] is True
|
||
assert catalog['summary']['technique_count'] >= 60
|
||
assert catalog['summary']['runnable_count'] >= 20
|
||
assert '/api/ashtakavarga' in catalog['filters']['api_endpoints']
|
||
assert '/api/tajika' in catalog['filters']['api_endpoints']
|
||
assert '/api/deep_varga_avastha' in catalog['filters']['api_endpoints']
|
||
assert catalog['example_payloads']['/api/ashtakavarga']['planets']
|
||
assert catalog['example_payloads']['/api/deep_varga_avastha']['planets']
|
||
assert any(row['id'] == 'ashtakavarga_pav' and row['runnable'] for row in catalog['techniques'])
|
||
assert any(row['id'] == 'deep_varga_avastha' and row['runnable'] for row in catalog['techniques'])
|
||
|
||
result = handler._compute_technique_example({'endpoint': '/api/ashtakavarga'})
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'technique_example'
|
||
assert result['target_endpoint'] == '/api/ashtakavarga'
|
||
assert result['result']['summary']['strongest_houses']
|
||
|
||
deep = handler._compute_technique_example({'endpoint': '/api/deep_varga_avastha'})
|
||
assert deep['success'] is True
|
||
assert deep['target_endpoint'] == '/api/deep_varga_avastha'
|
||
assert deep['result']['report']['deep_varga_templates']['D60']['template_cards']
|
||
|
||
with pytest.raises(BadRequest):
|
||
handler._compute_technique_example({'endpoint': '/api/report_artifact'})
|
||
|
||
|
||
def test_chara_dasha_endpoint_alias_returns_jaimini_dasha_payload() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_chara_dasha({
|
||
'planets': jyotish_api_server.SAMPLE_PLANETS,
|
||
'ascendant': jyotish_api_server.SAMPLE_ASCENDANT,
|
||
'year': 1990,
|
||
'month': 1,
|
||
'day': 1,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 28.6,
|
||
'lon': 77.2,
|
||
'tz': 5.5,
|
||
'antardasha': True,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'chara_dasha'
|
||
assert result['alias_of'] == 'jaimini'
|
||
assert result['mode'] == 'dasha'
|
||
assert result['result']['chara_dasha']
|
||
|
||
|
||
def test_capability_audit_lists_chara_dasha_endpoint() -> None:
|
||
handler = _handler()
|
||
audit = handler._capability_audit()
|
||
|
||
assert '/api/dasha/chara' in audit['surfaces']['api_endpoints']
|
||
|
||
|
||
def test_technique_catalog_exposes_chara_dasha_example() -> None:
|
||
handler = _handler()
|
||
catalog = handler._technique_catalog()
|
||
|
||
assert '/api/dasha/chara' in catalog['filters']['api_endpoints']
|
||
assert catalog['example_payloads']['/api/dasha/chara']['antardasha'] is True
|
||
|
||
result = handler._compute_technique_example({'endpoint': '/api/dasha/chara'})
|
||
assert result['success'] is True
|
||
assert result['target_endpoint'] == '/api/dasha/chara'
|
||
assert result['result']['result']['chara_dasha']
|
||
|
||
|
||
def test_thematic_report_declares_orchestrator_fragments() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_thematic_report({'theme': 'marriage'})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'thematic_report'
|
||
assert 'reading_orchestrator.py' in result['fragment_sources']
|
||
assert 'orchestrator_bridge.py' in result['fragment_sources']
|
||
assert result['workflow_orchestration']['bridge']['class'] == 'OrchestratorBridge'
|
||
assert result['workflow_orchestration']['reading_theme_count'] >= 7
|
||
assert 'marriage' in result['workflow_orchestration']['selected_report_themes']
|
||
|
||
|
||
def test_thematic_report_derives_evidence_from_birth_payload() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_thematic_report({
|
||
'theme': ['marriage', 'career', 'wealth'],
|
||
'year': 1990,
|
||
'month': 1,
|
||
'day': 1,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 39.9,
|
||
'lon': 116.4,
|
||
'tz': 8,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['mode'] == 'derived_chart_evidence'
|
||
assert result['evidence_source']['sample_fallback'] is False
|
||
assert result['evidence_source']['source'] == 'full_reading_modules'
|
||
assert result['evidence_source']['full_reading_used'] is True
|
||
assert result['evidence_source']['full_reading_module_count'] >= 40
|
||
assert result['evidence_source']['module_status']['full_reading'] == 'ok'
|
||
assert result['evidence_source']['evidence_counts']['marriage'] >= 3
|
||
assert result['evidence_source']['evidence_counts']['career'] >= 2
|
||
marriage_sources = {
|
||
item['details']['source']
|
||
for item in result['themes']['marriage']['evidence']
|
||
}
|
||
assert 'chart' in marriage_sources
|
||
assert 'full_reading.modules.marriage_counting' in marriage_sources
|
||
assert 'full_reading.modules.relationship_strict_evidence.user_narrative' in marriage_sources
|
||
assert any(item['details'].get('derived') for item in result['themes']['career']['evidence'])
|
||
|
||
|
||
def test_thematic_report_derives_relationship_strict_narrative_evidence() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_thematic_report({
|
||
'theme': ['marriage'],
|
||
'year': 1990,
|
||
'month': 1,
|
||
'day': 1,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 39.9,
|
||
'lon': 116.4,
|
||
'tz': 8,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
marriage_evidence = result['themes']['marriage']['evidence']
|
||
strict_rows = [
|
||
item for item in marriage_evidence
|
||
if item['details'].get('source') == 'full_reading.modules.relationship_strict_evidence.user_narrative'
|
||
]
|
||
assert strict_rows
|
||
strict_note = strict_rows[0]['conclusion']
|
||
assert 'dual dasha' in strict_note
|
||
assert 'D9' in strict_note
|
||
assert 'legal_marriage' in strict_note or '婚恋' in strict_note
|
||
|
||
|
||
def test_fragment_audit_blocks_registry_surface_drift() -> None:
|
||
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
|
||
from audit_fragments import audit
|
||
|
||
result = audit()
|
||
assert result['valid'] is True, result['problems']
|
||
assert result['registry']['technique_count'] >= 60
|
||
assert result['workspace_residue']['untracked_count'] >= 0
|
||
assert isinstance(result['workspace_residue']['untracked_files'], list)
|
||
assert result['workspace_residue']['git_lost_found_count'] >= 0
|
||
assert isinstance(result['workspace_residue']['git_lost_found_files'], list)
|
||
assert result['open_source_sources']['source_count'] >= 3
|
||
assert all(row['commands'] for row in result['rows'] if row['status'] in {'covered', 'complete'})
|
||
assert not any(problem['kind'] == 'missing_output_path' for problem in result['problems'])
|
||
|
||
|
||
def test_fragment_audit_accepts_script_symbol_output_paths() -> None:
|
||
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
|
||
from audit_fragments import output_path_exists
|
||
|
||
assert output_path_exists("scripts/yoga_engine.py:is_badhaka")[0] is True
|
||
assert output_path_exists("scripts/prashna.py:calc_sphutas")[0] is True
|
||
assert output_path_exists("scripts/tajika.py.graha_yuddha")[0] is True
|
||
|
||
|
||
def _sample_planets() -> dict:
|
||
return {
|
||
'Sun': {'lon': 80.0},
|
||
'Moon': {'lon': 123.0},
|
||
'Mars': {'lon': 210.0},
|
||
'Mercury': {'lon': 75.0},
|
||
'Jupiter': {'lon': 15.0},
|
||
'Venus': {'lon': 102.0},
|
||
'Saturn': {'lon': 330.0},
|
||
'Rahu': {'lon': 5.0},
|
||
'Ketu': {'lon': 185.0},
|
||
}
|
||
|
||
|
||
def test_muhurta_endpoint_returns_activity_checks() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_muhurta({
|
||
'date': '2026-06-22',
|
||
'activity': 'business',
|
||
'planets': _sample_planets(),
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['report']['query_date'] == '2026-06-22'
|
||
assert 'business' in result['report']['activity_checks']
|
||
|
||
|
||
def test_muhurta_endpoint_returns_date_range_solver() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_muhurta({
|
||
'start_date': '2026-06-22',
|
||
'end_date': '2026-06-28',
|
||
'activity': 'business',
|
||
'limit': 3,
|
||
'lat': 28.6,
|
||
'lon': 77.2,
|
||
'tz': 5.5,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'muhurta'
|
||
solver = result['range_search']
|
||
assert solver['mode'] == 'muhurta_date_range_solver'
|
||
assert solver['activity'] == 'business'
|
||
assert solver['candidate_count'] <= 3
|
||
assert solver['best_windows']
|
||
assert solver['constraints']['avoid_inauspicious_periods'] is True
|
||
|
||
|
||
def test_panchanga_range_endpoint_returns_calendar_rows() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_panchanga_range({
|
||
'start_date': '2026-06-22',
|
||
'end_date': '2026-06-24',
|
||
'sunrise': '06:00',
|
||
'sunset': '18:00',
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'panchanga_range'
|
||
assert result['report']['day_count'] == 3
|
||
assert result['report']['days'][0]['inauspicious_periods']['rahu_kala']['label'] == 'Rahu Kala'
|
||
assert 'condition_tags' in result['report']['days'][0]
|
||
assert 'festival_details' in result['report']['days'][0]
|
||
assert 'search_summary' in result['report']
|
||
assert result['report']['calculation_policy']['festival_rules']
|
||
|
||
|
||
def test_panchanga_range_endpoint_uses_location_when_available() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_panchanga_range({
|
||
'start_date': '2026-06-22',
|
||
'end_date': '2026-06-22',
|
||
'lat': 28.6,
|
||
'lon': 77.2,
|
||
'tz': 5.5,
|
||
})
|
||
|
||
assert result['report']['location']['lon'] == 77.2
|
||
assert result['report']['calculation_policy']['sunrise_sunset'] in {
|
||
'SwissEph rise_trans',
|
||
'location-aware solar approximation',
|
||
'mixed SwissEph rise_trans with approximation fallback',
|
||
}
|
||
assert 'solar_times' in result['report']['days'][0]
|
||
|
||
|
||
def test_panchanga_range_rejects_large_ranges() -> None:
|
||
handler = _handler()
|
||
with pytest.raises(BadRequest, match='panchanga range must be <= 63 days'):
|
||
handler._compute_panchanga_range({
|
||
'start_date': '2026-01-01',
|
||
'end_date': '2026-04-01',
|
||
})
|
||
|
||
|
||
def test_rectification_gate_returns_varga_risk_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_rectification_gate({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'declared_accuracy': 'minute',
|
||
'time_source': 'family_vague',
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'rectification_gate'
|
||
assert result['effective_accuracy'] == '15min'
|
||
assert 'headline' in result['summary']
|
||
assert result['summary']['recommended_events']
|
||
|
||
|
||
def test_case_validation_endpoint_returns_evidence_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_case_validation({
|
||
'planets': {
|
||
**_sample_planets(),
|
||
'Moon': {'lon': 45.0},
|
||
'Venus': {'lon': 40.0},
|
||
'Saturn': {'lon': 10.0},
|
||
},
|
||
'ascendant': {'lon': 0.0},
|
||
'current_md': 'Venus',
|
||
'predicted_events': ['艺术创作', '关系发展'],
|
||
'transit_desc': 'Jupiter tr 7',
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'case_validation'
|
||
assert result['summary']['validated_count'] >= 1
|
||
assert 'overall_confidence' in result['summary']
|
||
assert 'mevg_automation.py' in result['fragment_sources']
|
||
assert result['mevg_gate']['source'] == 'mevg_automation.py'
|
||
assert result['summary']['gate_status'] in {'NOT_INITIALIZED', 'OPEN', 'CLOSED', 'UNKNOWN', 'UNAVAILABLE'}
|
||
|
||
|
||
def test_divisional_yoga_endpoint_returns_varga_yoga_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_divisional_yoga({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'divisions': ['D9', 'D10', 'D12'],
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'divisional_yoga'
|
||
assert result['summary']['total_yogas'] >= 0
|
||
assert {'D9', 'D10', 'D12'} <= set(result['result'])
|
||
|
||
|
||
def test_deep_varga_avastha_endpoint_returns_templates() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_deep_varga_avastha({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'deep_varga_avastha'
|
||
report = result['report']
|
||
assert report['avastha_summary']['dominant_states']
|
||
assert {'D24', 'D30', 'D60'} <= set(report['deep_varga_templates'])
|
||
assert report['deep_varga_templates']['D24']['template_cards']
|
||
assert report['deep_varga_templates']['D30']['risk_flags']
|
||
assert report['deep_varga_templates']['D60']['next_action']
|
||
|
||
|
||
def test_kakshya_endpoint_returns_degree_trigger_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_kakshya({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'kakshya'
|
||
assert result['summary']['average_strength'] >= 0
|
||
assert result['summary']['strongest']
|
||
assert 'planets' in result['result']
|
||
|
||
|
||
def test_bhava_bala_endpoint_returns_house_strength_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_bhava_bala_api({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'bhava_bala'
|
||
assert result['summary']['strongest']
|
||
assert result['summary']['weakest']
|
||
assert 'houses' in result['result']
|
||
|
||
|
||
def test_transit_endpoint_returns_trigger_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_transit_triggers({
|
||
'natal_planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'start': '2026-06-22',
|
||
'end': '2026-07-22',
|
||
'planets_to_check': ['Saturn', 'Jupiter'],
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'transit'
|
||
assert 'total_triggers' in result['summary']
|
||
assert 'triggers' in result
|
||
|
||
|
||
def test_annual_endpoint_returns_varshaphala_report() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_annual({
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 28.6,
|
||
'lon': 77.2,
|
||
'tz': 5.5,
|
||
'target_year': 2026,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['report']['target_year'] == 2026
|
||
assert 'muntha' in result['report']
|
||
strength = result['report']['tajika_strength']
|
||
assert strength['method'] == 'Tajika Harsha/Panchavargiya Bala'
|
||
assert 'harsha_bala' in strength
|
||
assert 'panchavargiya_bala' in strength
|
||
assert strength['summary']['strongest_planets']
|
||
assert strength['summary']['next_action']
|
||
|
||
|
||
def test_tajika_endpoint_alias_returns_varshaphala_report() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_tajika({
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 28.6,
|
||
'lon': 77.2,
|
||
'tz': 5.5,
|
||
'target_year': 2026,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['endpoint'] == 'tajika'
|
||
assert result['alias_of'] == 'annual'
|
||
assert result['report']['target_year'] == 2026
|
||
assert 'muntha' in result['report']
|
||
strength = result['report']['tajika_strength']
|
||
assert strength['method'] == 'Tajika Harsha/Panchavargiya Bala'
|
||
assert strength['summary']['strongest_planets']
|
||
|
||
|
||
def test_bhava_chalit_endpoint_compares_shifted_houses() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_bhava_chalit({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'mc_lon': 10.0,
|
||
'house_system': 'sripati',
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['result']['house_system'] == 'sripati'
|
||
assert 'rashi_chart' in result['result']
|
||
|
||
|
||
def test_bhava_chalit_endpoint_exposes_user_selected_house_systems() -> None:
|
||
handler = _handler()
|
||
base = {
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'mc_lon': 10.0,
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 28.6,
|
||
'lon': 77.2,
|
||
'tz': 5.5,
|
||
}
|
||
|
||
sripati = handler._compute_bhava_chalit({**base, 'house_system': 'sripati'})
|
||
placidus = handler._compute_bhava_chalit({**base, 'house_system': 'placidus'})
|
||
|
||
for result, expected in [(sripati, 'sripati'), (placidus, 'placidus')]:
|
||
assert result['success'] is True
|
||
assert result['requested_house_system'] == expected
|
||
assert result['selected_house_system'] == expected
|
||
assert 'placidus' in result['available_house_systems']
|
||
assert 'sripati' in result['available_house_systems']
|
||
assert result['result']['selected_house_system'] == expected
|
||
assert result['result']['requested_house_system'] == expected
|
||
assert len(result['result']['boundaries']['houses']) == 12
|
||
assert result['result']['summary']['total_planets'] >= 7
|
||
assert result['result']['calculation_note']
|
||
|
||
|
||
def test_sudarshana_endpoint_returns_three_reference_points() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_sudarshana({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert {'ascendant_lagna', 'moon_lagna', 'sun_lagna'} <= set(result['result']['reference_points'])
|
||
|
||
|
||
def test_nakshatra_full_endpoint_returns_power_layers() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_nakshatra_full({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'age': 36,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert 'tara_bala' in result['result']
|
||
assert 'sub_lords' in result['result']
|
||
|
||
|
||
def test_varga_full_endpoint_returns_extended_standard_divisions() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_varga_full({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'divisions': ['D9', 'D60', 'D81', 'D108', 'D144'],
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['mode'] == 'standard'
|
||
assert result['divisions'] == [9, 60, 81, 108, 144]
|
||
assert 'D144_Dwadasamsa-Dwadasamsa' in result['result']
|
||
assert result['result']['D81_Navamsa-Navamsa']['planets']['Moon']['house'] in range(1, 13)
|
||
|
||
|
||
def test_varga_full_endpoint_supports_custom_and_composite_modes() -> None:
|
||
handler = _handler()
|
||
custom = handler._compute_varga_full({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'custom': 150,
|
||
})
|
||
composite = handler._compute_varga_full({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'composite': '9,12',
|
||
})
|
||
|
||
assert custom['mode'] == 'custom'
|
||
assert custom['result']['Moon']['div'] == 150
|
||
assert composite['mode'] == 'composite'
|
||
assert composite['result']['composite_div'] == 'D9×D12=D108'
|
||
|
||
|
||
def test_varga_full_endpoint_supports_d2_d3_variants() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_varga_full({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'divisions': 'D3',
|
||
'variant': 'khara',
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['mode'] == 'variant'
|
||
assert result['result']['div'] == 3
|
||
assert result['result']['Moon']['variant'] == 'khara'
|
||
|
||
|
||
def test_jaimini_endpoint_returns_karakas_and_arudha() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_jaimini({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'year': 1990,
|
||
'month': 6,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert 'chara_karaka_7' in result['result']
|
||
assert 'Atmakaraka' in result['result']['chara_karaka_7']['karaka_table']
|
||
assert 'arudha_padas' in result['result']
|
||
|
||
|
||
def test_ashtakavarga_endpoint_preserves_sav_invariant() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_ashtakavarga({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['result']['sav']['total'] == 337
|
||
assert result['result']['sav']['valid'] is True
|
||
assert result['summary']['strongest_houses']
|
||
assert result['pav_summary']['top_planets']
|
||
assert result['sodhita_summary']['top_signs']
|
||
|
||
|
||
def test_remedies_endpoint_returns_evidence_chain() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_remedies({
|
||
'shadbala': {
|
||
'Sun': {'total_rupas': 0.42},
|
||
'Moon': {'rupas': 0.68},
|
||
},
|
||
'dasha_lord': 'Sun',
|
||
'doshas': ['Mangal Dosha'],
|
||
})
|
||
|
||
assert result['weak_planets'] == ['Sun']
|
||
assert 'evidence_chain' in result
|
||
assert any(item['source'] == 'shadbala' and item['planet'] == 'Sun' for item in result['evidence_chain'])
|
||
assert any(item['source'] == 'dasha' for item in result['evidence_chain'])
|
||
assert result['next_action']
|
||
|
||
|
||
def test_shadbala_endpoint_returns_ranked_planet_strength() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_shadbala({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
'hour': 12,
|
||
'minute': 0,
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['result']['ranking']
|
||
assert 'total_rupas' in result['result']['planets']['Sun']
|
||
assert result['rule_variants']['selected'] == ['core_sixfold', 'advanced_evidence']
|
||
assert result['advanced_layer']['source'] == 'scripts/shadbala_advanced.py'
|
||
assert result['advanced_layer']['top_kala_support']
|
||
assert 'sputa_drik_bala' in result['advanced_layer']
|
||
|
||
|
||
def test_chart_ai_prompt_pack_exposes_functional_benefic_malefic_layer() -> None:
|
||
handler = _handler()
|
||
|
||
result = handler._compute_chart({
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 39.9,
|
||
'lon': 116.4,
|
||
'tz': 8,
|
||
})
|
||
|
||
prompt_pack = result['ai_prompt_pack']
|
||
functional = prompt_pack['evidence_snapshot']['functional_benefic_malefic']
|
||
assert functional['status'] == 'used'
|
||
assert functional['ascendant']
|
||
assert isinstance(functional['functional_benefics'], list)
|
||
assert isinstance(functional['functional_malefics'], list)
|
||
assert functional['effect_on_confidence']
|
||
vedastro = prompt_pack['evidence_snapshot']['vedastro_overview']
|
||
assert vedastro['source'] == 'vedastro_service_adapter_candidate'
|
||
assert vedastro['ingestion_profile'] == 'main_entry_overview'
|
||
assert vedastro['visibility'] == 'user_visible_overview_only'
|
||
|
||
|
||
def test_chart_auto_attaches_vedastro_main_entry_boundary(monkeypatch: pytest.MonkeyPatch) -> None:
|
||
monkeypatch.setenv("VEDASTRO_API_ENDPOINT", "https://example.invalid/api")
|
||
monkeypatch.setenv("VEDASTRO_ENABLE_NETWORK", "0")
|
||
monkeypatch.setenv("JYOTISH_SKIP_LOCAL_ENV", "1")
|
||
|
||
handler = _handler()
|
||
result = handler._compute_chart({
|
||
'year': 1990,
|
||
'month': 6,
|
||
'day': 15,
|
||
'hour': 12,
|
||
'minute': 0,
|
||
'lat': 39.9,
|
||
'lon': 116.4,
|
||
'tz': 8,
|
||
})
|
||
|
||
assert "modules" in result
|
||
vedastro = result["modules"]["vedastro_range_scan_result"]
|
||
assert vedastro["backend"] == "vedastro_service_adapter_candidate"
|
||
assert vedastro["status"] == "network_execution_disabled"
|
||
assert vedastro["source_metadata"]["ingestion_profile"] == "main_entry_overview"
|
||
assert vedastro["source_metadata"]["reference_date"]
|
||
assert sorted(vedastro["source_metadata"]["domain_statuses"]) == ["career", "marriage", "wealth"]
|
||
|
||
|
||
def test_yogas_endpoint_returns_summary_counts() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_yogas_api({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert 'extended_count' in result['result']['summary']
|
||
assert 'rule_engine_count' in result['result']['summary']
|
||
assert 'curse_count' in result['result']['summary']
|
||
assert any(item['key'] == 'curse_conjunctions' for item in result['rule_variants']['available'])
|
||
|
||
|
||
def test_yogas_endpoint_reuses_curse_yoga_fragment() -> None:
|
||
handler = _handler()
|
||
planets = _sample_planets()
|
||
planets['Mars'] = {'lon': 210.0}
|
||
planets['Saturn'] = {'lon': 211.0}
|
||
result = handler._compute_yogas_api({
|
||
'planets': planets,
|
||
'ascendant': {'lon': 92.0},
|
||
'current_dasha': 'Saturn',
|
||
})
|
||
|
||
curse_layer = result['result']['curse_yogas']
|
||
assert result['success'] is True
|
||
assert result['result']['summary']['curse_count'] == 1
|
||
assert curse_layer['overall_risk'] in {'high', 'critical'}
|
||
assert curse_layer['curses_detected'][0]['type'] == 'yama_yoga'
|
||
assert result['rule_variants']['selected'][-1] == 'curse_conjunctions'
|
||
|
||
|
||
def test_aspects_endpoint_returns_pair_summary() -> None:
|
||
handler = _handler()
|
||
result = handler._compute_aspects({
|
||
'planets': _sample_planets(),
|
||
'ascendant': {'lon': 92.0},
|
||
})
|
||
|
||
assert result['success'] is True
|
||
assert result['result']['summary']['total_aspects'] >= 0
|
||
assert 'by_type' in result['result']['summary']
|