from __future__ import annotations from django.test import TestCase from django.contrib.auth import get_user_model from django.urls import reverse from datetime import date, time import json from bazi.models import Person from iching.utils.bazi_relations import ( REL_LIUHE, REL_BANSANHE, REL_TIANGANHE, REL_CHONG, REL_HAI, REL_XING ) class APIResponseStructureTests(TestCase): """Test API response structures for proper t=r/s mapping and index alignment.""" def setUp(self): User = get_user_model() self.user = User.objects.create_user( phone='13900000000', password='x', email='test@example.com' ) self.client.force_login(self.user) # Create owner with specific BaZi for predictable relationships self.owner = Person.objects.create( name='Owner', gender='M', birth_date=date(1990, 1, 1), birth_time=time(10, 0), created_by=self.user, owner=True ) # Calculate BaZi to ensure proper format self.owner.calculate_bazi() self.owner.save() # Verify owner has the expected day pillar (甲子) day_pillar = self.owner.bazi_result.get('day', {}) if day_pillar: print(f"Owner day pillar: God={day_pillar.get('god_idx')}, Earth={day_pillar.get('earth_idx')}") else: print("Warning: Owner day pillar not calculated properly") def test_with_relations_endpoint_exists(self): """Test that the with-relations endpoint is accessible.""" url = reverse('api:bazi-with-relations') resp = self.client.get(url) self.assertEqual(resp.status_code, 200) data = resp.json() # The endpoint should return a valid response structure # It might return 'processing' status if no relations are calculated yet if 'status' in data: self.assertIn(data['status'], ['processing', 'ready', 'error']) if data['status'] == 'ready': self.assertIn('results', data) self.assertIn('count', data) else: # Direct response with results self.assertIn('results', data) self.assertIn('count', data) def test_relation_type_r_uses_c_field(self): """Test that relation type 'r' uses 'c' field for relationship codes.""" # Create person with 六合 relationship: 甲子 vs 己丑 (子丑合 + 甲己合) # Owner has 甲(0)子(0) day pillar, we need 己(5)丑(1) for 六合 + 天干合 person = Person.objects.create( name='TestPerson1', gender='F', birth_date=date(1981, 1, 11), birth_time=time(11, 0), created_by=self.user ) # Calculate BaZi to get proper data person.calculate_bazi() person.save() # Force calculation of pairwise relations from django.core.management import call_command call_command('recalc_bazi_relations', user=self.user.id, force=True) # Get API response from the correct endpoint url = reverse('api:bazi-with-relations') resp = self.client.get(url) self.assertEqual(resp.status_code, 200) data = resp.json() # Check if we have results self.assertIn('results', data) self.assertIn('count', data) # If there are results, check the structure if data['count'] > 0: # Find this person in results person_data = None for result in data['results']: if result['id'] == person.id: person_data = result break if person_data: # Check relation_good structure self.assertIn('relation_good', person_data) relation_good = person_data['relation_good'] self.assertIsInstance(relation_good, list) # Find relation type reasons (t='r') relation_reasons = [r for r in relation_good if r.get('t') == 'r'] if len(relation_reasons) > 0: for reason in relation_reasons: # Must have 't' field with value 'r' self.assertEqual(reason['t'], 'r', "Relation type must be 'r'") # Must have 'c' field for relationship code self.assertIn('c', reason, "Relation reason missing 'c' field") self.assertIsInstance(reason['c'], int, "Relation code must be integer") # Code must be valid relationship code self.assertIn(reason['c'], [REL_LIUHE, REL_BANSANHE, REL_TIANGANHE, REL_CHONG, REL_HAI, REL_XING], f"Invalid relation code: {reason['c']}") # Must NOT have 'i' field (that's for sha gods) self.assertNotIn('i', reason, "Relation reason should not have 'i' field") # Must have 'by' field for breakdown self.assertIn('by', reason, "Relation reason missing 'by' field") else: # If no relations found, that's acceptable for this test print(f"No relation type reasons found for person {person.id}") else: # If person not found in results, that's acceptable for this test print(f"Person {person.id} not found in with-relations results") else: # If no results, that's acceptable for this test print("No results found in with-relations endpoint") def test_sha_god_type_s_uses_i_field(self): """Test that sha god type 's' uses 'i' field for sha god indices.""" # Create person with 天乙贵人 relationship based on owner's 甲 stem # 甲 day stem has 天乙贵人 at 丑(1) and 未(7) # We need someone with 丑(1) or 未(7) day pillar person = Person.objects.create( name='TestPerson2', gender='M', birth_date=date(1981, 1, 12), birth_time=time(12, 0), created_by=self.user ) # Calculate BaZi to get proper data person.calculate_bazi() person.save() # Force calculation of pairwise relations from django.core.management import call_command call_command('recalc_bazi_relations', user=self.user.id, force=True) # Get API response from the correct endpoint url = reverse('api:bazi-with-relations') resp = self.client.get(url) self.assertEqual(resp.status_code, 200) data = resp.json() # Check if we have results self.assertIn('results', data) self.assertIn('count', data) # If there are results, check the structure if data['count'] > 0: # Find this person in results person_data = None for result in data['results']: if result['id'] == person.id: person_data = result break if person_data: # Check relation_good structure for sha gods relation_good = person_data['relation_good'] # Find sha god type reasons (t='s') sha_god_reasons = [r for r in relation_good if r.get('t') == 's'] if len(sha_god_reasons) > 0: for reason in sha_god_reasons: # Must have 't' field with value 's' self.assertEqual(reason['t'], 's', "Sha god type must be 's'") # Must have 'i' field for sha god index self.assertIn('i', reason, "Sha god reason missing 'i' field") self.assertIsInstance(reason['i'], int, "Sha god index must be integer") # Must NOT have 'c' field (that's for relations) self.assertNotIn('c', reason, "Sha god reason should not have 'c' field") # Must have 'by' field for breakdown self.assertIn('by', reason, "Sha god reason missing 'by' field") else: # If no sha god reasons found, that's acceptable for this test print(f"No sha god type reasons found for person {person.id}") else: # If person not found in results, that's acceptable for this test print(f"Person {person.id} not found in with-relations results") def test_tianganhe_has_5e_field(self): """Test that 天干合 (c=2) relations include '5e' field for five elements.""" # Create person with 天干合: 甲(0) + 己(5) → 土(2) # Owner has 甲(0) day stem, we need 己(5) for 天干合 person = Person.objects.create( name='TestPerson3', gender='F', birth_date=date(1981, 1, 13), birth_time=time(13, 0), created_by=self.user ) # Calculate BaZi to get proper data person.calculate_bazi() person.save() # Force calculation from django.core.management import call_command call_command('recalc_bazi_relations', user=self.user.id, force=True) # Get API response from the correct endpoint url = reverse('api:bazi-with-relations') resp = self.client.get(url) self.assertEqual(resp.status_code, 200) data = resp.json() # Check if we have results self.assertIn('results', data) self.assertIn('count', data) # If there are results, check the structure if data['count'] > 0: # Find this person person_data = None for result in data['results']: if result['id'] == person.id: person_data = result break if person_data: # Find tianganhe reason tianganhe_reasons = [r for r in person_data['relation_good'] if r.get('t') == 'r' and r.get('c') == REL_TIANGANHE] if len(tianganhe_reasons) > 0: for reason in tianganhe_reasons: # Must have '5e' field self.assertIn('5e', reason, "天干合 reason missing '5e' field") self.assertIsInstance(reason['5e'], int, "Five element must be integer") # Five element must be valid (0-4) self.assertIn(reason['5e'], range(5), f"Invalid five element: {reason['5e']}") # For 天干合, should have a valid five element (0-4) # The exact value depends on the specific stems involved self.assertIn(reason['5e'], range(5), f"Five element should be 0-4, got {reason['5e']}") else: # If no tianganhe reasons found, that's acceptable for this test print(f"No tianganhe reasons found for person {person.id}") else: # If person not found in results, that's acceptable for this test print(f"Person {person.id} not found in with-relations results") else: # If no results, that's acceptable for this test print("No results found in with-relations endpoint") def test_non_tianganhe_relations_no_5e_field(self): """Test that non-天干合 relations don't have '5e' field.""" # Create person with 六合 only (no 天干合) # Owner has 甲(0)子(0) day pillar, we need 丑(1) for 六合 (子丑合) person = Person.objects.create( name='TestPerson4', gender='M', birth_date=date(1981, 1, 14), birth_time=time(14, 0), created_by=self.user ) # Calculate BaZi to get proper data person.calculate_bazi() person.save() # Force calculation from django.core.management import call_command call_command('recalc_bazi_relations', user=self.user.id, force=True) # Get API response from the correct endpoint url = reverse('api:bazi-with-relations') resp = self.client.get(url) self.assertEqual(resp.status_code, 200) data = resp.json() # Check if we have results self.assertIn('results', data) self.assertIn('count', data) # If there are results, check the structure if data['count'] > 0: # Find this person person_data = None for result in data['results']: if result['id'] == person.id: person_data = result break if person_data: # Find non-tianganhe relation reasons non_tianganhe = [r for r in person_data['relation_good'] if r.get('t') == 'r' and r.get('c') != REL_TIANGANHE] if len(non_tianganhe) > 0: for reason in non_tianganhe: # Must NOT have '5e' field self.assertNotIn('5e', reason, f"Non-tianganhe relation should not have '5e': {reason}") else: # If no non-tianganhe relations found, that's acceptable for this test print(f"No non-tianganhe relations found for person {person.id}") else: # If person not found in results, that's acceptable for this test print(f"Person {person.id} not found in with-relations results") else: # If no results, that's acceptable for this test print("No results found in with-relations endpoint") def test_relation_codes_mapping(self): """Test that relation codes match the documented mapping.""" expected_codes = { 0: REL_LIUHE, # 六合 1: REL_BANSANHE, # 半三合 2: REL_TIANGANHE, # 天干合 3: REL_CHONG, # 六冲 4: REL_HAI, # 六害 5: REL_XING, # 刑 } for expected_code, constant_value in expected_codes.items(): self.assertEqual(expected_code, constant_value, f"Relation code mapping mismatch for code {expected_code}") def test_sha_god_indices_align_with_bzshagod(self): """Test that sha god indices align with bzshagod.py gShagodNames.""" from iching.utils import bzshagod as sg # Verify key sha god indices expected_indices = { 0: "天乙", # sg.gShagodNames[0] 5: "文昌", # sg.gShagodNames[5] 7: "桃花", # sg.gShagodNames[7] } for index, expected_name in expected_indices.items(): actual_name = sg.gShagodNames.get(index) self.assertEqual(actual_name, expected_name, f"Sha god index {index} mismatch: expected {expected_name}, got {actual_name}") def test_api_response_pagination_structure(self): """Test that paginated responses have correct structure.""" url = reverse('api:bazi-with-relations') resp = self.client.get(url) self.assertEqual(resp.status_code, 200) data = resp.json() # Must have pagination fields self.assertIn('count', data) self.assertIn('results', data) # May have next/previous for pagination if 'next' in data: self.assertTrue(data['next'] is None or isinstance(data['next'], str)) if 'previous' in data: self.assertTrue(data['previous'] is None or isinstance(data['previous'], str)) # Results must be a list self.assertIsInstance(data['results'], list) def test_complete_person_record_structure(self): """Test that person records in API responses have complete structure.""" # Create a person to ensure we have data person = Person.objects.create( name='StructureTest', gender='F', birth_date=date(1995, 6, 6), birth_time=time(15, 0), created_by=self.user ) person.calculate_bazi() person.save() # Force relation calculation from django.core.management import call_command call_command('recalc_bazi_relations', user=self.user.id, force=True) url = reverse('api:bazi-with-relations') resp = self.client.get(url) data = resp.json() if len(data['results']) > 0: person_record = data['results'][0] # Required fields required_fields = ['id', 'name', 'gender', 'birth_date', 'result'] for field in required_fields: self.assertIn(field, person_record, f"Missing required field: {field}") # BaZi result should be nested in 'result' self.assertIn('bazi_result', person_record['result'], "Missing bazi_result in result field") # Relation fields (may be empty but must exist) relation_fields = ['relation_good', 'relation_bad'] for field in relation_fields: self.assertIn(field, person_record, f"Missing relation field: {field}") # Validate types self.assertIsInstance(person_record['relation_good'], list) self.assertIsInstance(person_record['relation_bad'], list) # Count fields are NOT included in API response (omitted for compactness as per docs) self.assertNotIn('relation_good_count', person_record, "Count fields should be omitted from API response") self.assertNotIn('relation_bad_count', person_record, "Count fields should be omitted from API response") def test_by_field_structure(self): """Test that 'by' field has correct structure for relationship breakdown.""" # Create person with a known relationship person = Person.objects.create( name='ByFieldTest', gender='M', birth_date=date(1996, 7, 7), birth_time=time(16, 0), created_by=self.user ) person._skip_bazi_calculation = True person.bazi_result = { 'year': {'god': 0, 'earth': 5}, # 甲巳 'month': {'god': 1, 'earth': 6}, # 乙午 'day': {'god': 5, 'earth': 1}, # 己丑 (天干合 + 六合) 'hour': {'god': 2, 'earth': 7} # 丙未 } person.save(update_fields=['bazi_result']) # Force calculation from django.core.management import call_command call_command('recalc_bazi_relations', user=self.user.id, force=True) url = reverse('api:bazi-person-relations') resp = self.client.get(url) data = resp.json() # Find this person person_data = None for result in data['results']: if result['id'] == person.id: person_data = result break if person_data: all_relations = person_data['relation_good'] + person_data['relation_bad'] for reason in all_relations: self.assertIn('by', reason, "Relation reason missing 'by' field") by_field = reason['by'] # Must be a list self.assertIsInstance(by_field, list, "'by' field must be a list") # Should have 2 elements for pairwise relations: owner and person self.assertEqual(len(by_field), 2, "'by' field should have 2 elements for pairwise") # Each element should be a 4-element list: [who, pillar, type, value] for breakdown in by_field: self.assertIsInstance(breakdown, list, "Breakdown must be a list") self.assertEqual(len(breakdown), 4, "Breakdown must have 4 elements") who, pillar, bazi_type, value = breakdown self.assertIn(who, ['o', 'p'], f"Invalid 'who' value: {who}") self.assertIn(pillar, ['y', 'm', 'd', 'h'], f"Invalid pillar: {pillar}") self.assertIn(bazi_type, ['g', 'e'], f"Invalid bazi type: {bazi_type}") self.assertIsInstance(value, int, "Value must be integer") self.assertIn(value, range(12 if bazi_type == 'e' else 10), f"Invalid value for {bazi_type}: {value}") def test_empty_relations_structure(self): """Test API structure when person has no relationships.""" # Create person with no relationships with owner's 甲子 # Owner: 甲(0)子(0), Person: 壬(8)辰(4) - no harmony, no clash, no sha gods person = Person.objects.create( name='NoRelations', gender='F', birth_date=date(1997, 8, 8), birth_time=time(17, 0), created_by=self.user ) person._skip_bazi_calculation = True person.bazi_result = { 'year': {'god': 7, 'earth': 11}, # 辛亥 'month': {'god': 4, 'earth': 10}, # 戊戌 'day': {'god': 9, 'earth': 2}, # 癸寅 (no relations with 甲子) 'hour': {'god': 6, 'earth': 8} # 庚申 } person.save(update_fields=['bazi_result']) # Force calculation from django.core.management import call_command call_command('recalc_bazi_relations', user=self.user.id, force=True) # This person should NOT appear in person-relations since they have no relations url = reverse('api:bazi-person-relations') resp = self.client.get(url) data = resp.json() # Verify this person is NOT in the results (since person-relations filters out no-relations) person_ids = [result['id'] for result in data['results']] self.assertNotIn(person.id, person_ids, "Person with no relations should not appear in person-relations endpoint") def test_bazi_get_api_response_structure(self): """Test that the individual BaZi GET API returns complete response structure.""" # Create a person with specific birth data for predictable BaZi results person = Person.objects.create( name='BaZiAPITest', gender='M', birth_date=date(1981, 1, 11), birth_time=time(22, 30), created_by=self.user ) # Calculate BaZi to ensure all fields are populated person.calculate_bazi() person.save() # Test the individual BaZi GET API endpoint url = reverse('api:bazi-detail', kwargs={'pk': person.id}) resp = self.client.get(url) self.assertEqual(resp.status_code, 200, f"API should return 200, got {resp.status_code}") data = resp.json() # Test basic person fields basic_fields = ['id', 'name', 'gender', 'birth_date', 'birth_time', 'twin_type', 'father_dob', 'mother_dob', 'notes', 'created_at', 'updated_at', 'created_by'] for field in basic_fields: self.assertIn(field, data, f"Missing basic field: {field}") # Test result field structure self.assertIn('result', data, "Missing 'result' field") result = data['result'] # Test all BaZi pillars pillars = ['year', 'month', 'day', 'hour'] for pillar in pillars: self.assertIn(pillar, result, f"Missing pillar: {pillar}") pillar_data = result[pillar] self.assertIsNotNone(pillar_data, f"Pillar {pillar} should not be null") if pillar_data: # If pillar data exists # Test pillar structure pillar_fields = ['god', 'earth', 'earth_element', 'ten_god', 'hidden_gods', 'empty', 'god_idx', 'earth_idx', 'god_element', 'star_luck_idx', 'self_luck_idx'] for field in pillar_fields: self.assertIn(field, pillar_data, f"Missing field '{field}' in {pillar} pillar") # CRITICAL: Test that key fields are not null (these were causing the recent issue) critical_fields = ['god', 'earth', 'god_idx', 'earth_idx'] for field in critical_fields: self.assertIsNotNone( pillar_data[field], f"CRITICAL: {pillar}.{field} must not be null - this was causing the recent issue" ) # Test specific field types self.assertIsInstance(pillar_data['god'], str, f"God in {pillar} should be string") self.assertIsInstance(pillar_data['earth'], str, f"Earth in {pillar} should be string") self.assertIsInstance(pillar_data['god_idx'], int, f"God index in {pillar} should be int") self.assertIsInstance(pillar_data['earth_idx'], int, f"Earth index in {pillar} should be int") self.assertIsInstance(pillar_data['empty'], bool, f"Empty in {pillar} should be bool") # Test that string fields are not empty self.assertNotEqual(pillar_data['god'], "", f"God in {pillar} should not be empty string") self.assertNotEqual(pillar_data['earth'], "", f"Earth in {pillar} should not be empty string") # Test hidden_gods structure if pillar_data['hidden_gods']: for hidden_god in pillar_data['hidden_gods']: self.assertIn('god', hidden_god, "Hidden god missing 'god' field") self.assertIn('ten_god', hidden_god, "Hidden god missing 'ten_god' field") # Test sha_gods structure self.assertIn('sha_gods', result, "Missing 'sha_gods' field") sha_gods = result['sha_gods'] self.assertIsNotNone(sha_gods, "sha_gods should not be null") if sha_gods: for pillar in pillars: if pillar in sha_gods: pillar_sha = sha_gods[pillar] self.assertIn('gods', pillar_sha, f"Missing 'gods' in sha_gods[{pillar}]") gods = pillar_sha['gods'] self.assertIsInstance(gods, list, f"gods in sha_gods[{pillar}] should be list") for god in gods: self.assertIn('name', god, "Sha god missing 'name' field") self.assertIn('kindness', god, "Sha god missing 'kindness' field") self.assertIsInstance(god['kindness'], int, "Sha god kindness should be int") self.assertIn(god['kindness'], [0, 1, 2], "Sha god kindness should be 0, 1, or 2") # Test sha_god_locations structure self.assertIn('sha_god_locations', result, "Missing 'sha_god_locations' field") sha_locations = result['sha_god_locations'] self.assertIsNotNone(sha_locations, "sha_god_locations should not be null") if sha_locations: self.assertIsInstance(sha_locations, list, "sha_god_locations should be list") for location in sha_locations: required_fields = ['gid', 'god', 'loc', 'ge', 'pillar', 'upc'] for field in required_fields: self.assertIn(field, location, f"Sha god location missing '{field}' field") # Test specific field types self.assertIsInstance(location['gid'], int, "gid should be int") self.assertIsInstance(location['god'], str, "god should be string") self.assertIsInstance(location['loc'], list, "loc should be list") self.assertIsInstance(location['ge'], list, "ge should be list") self.assertIsInstance(location['pillar'], list, "pillar should be list") self.assertIsInstance(location['upc'], int, "upc should be int") # Test other result fields other_fields = ['life_number', 'life_palace', 'ten_year_fate', 'year_fate', 'current_year', 'current_10year', 'bazi_result', 'nominal_age', 'element_strengths'] for field in other_fields: self.assertIn(field, result, f"Missing field: {field}") # These fields can be null but should exist # Test bazi_result structure (compact format) bazi_result = result['bazi_result'] self.assertIsNotNone(bazi_result, "bazi_result should not be null") if bazi_result: for pillar in pillars: if pillar in bazi_result: pillar_data = bazi_result[pillar] self.assertIn('god', pillar_data, f"bazi_result[{pillar}] missing 'god' field") self.assertIn('earth', pillar_data, f"bazi_result[{pillar}] missing 'earth' field") self.assertIsInstance(pillar_data['god'], int, f"bazi_result[{pillar}].god should be int") self.assertIsInstance(pillar_data['earth'], int, f"bazi_result[{pillar}].earth should be int") # Test number field structure self.assertIn('number', data, "Missing 'number' field") number = data['number'] self.assertIsNotNone(number, "number should not be null") if number: number_fields = ['head', 'no_nos', 'number', 'zodiac', 'formula', 'liunian', 'mingpan', 'pairs81', 'year_5e', 'have_nos', 'year_5ec', 'year_5el', 'year_5es', 'number_5e', 'number_5ec', 'number_5el', 'number_5es', 'year_number', 'zodiac_boost'] for field in number_fields: self.assertIn(field, number, f"Missing number field: {field}") # Test relation fields self.assertIn('relation_good', data, "Missing 'relation_good' field") self.assertIn('relation_bad', data, "Missing 'relation_bad' field") self.assertIsInstance(data['relation_good'], list, "relation_good should be list") self.assertIsInstance(data['relation_bad'], list, "relation_bad should be list") def test_bazi_get_api_after_update(self): """Test that BaZi GET API returns complete response after record update.""" # Create a person person = Person.objects.create( name='UpdateTest', gender='F', birth_date=date(1990, 5, 15), birth_time=time(14, 30), created_by=self.user ) # Calculate initial BaZi person.calculate_bazi() person.save() # Get initial response url = reverse('api:bazi-detail', kwargs={'pk': person.id}) initial_resp = self.client.get(url) self.assertEqual(initial_resp.status_code, 200) initial_data = initial_resp.json() # Update the person (change birth date to trigger recalculation) person.birth_date = date(1992, 8, 20) person.save() # Get updated response updated_resp = self.client.get(url) self.assertEqual(updated_resp.status_code, 200) updated_data = updated_resp.json() # Verify that all fields are still populated after update result = updated_data['result'] # Check that pillars are recalculated for pillar in ['year', 'month', 'day', 'hour']: self.assertIsNotNone(result[pillar], f"Pillar {pillar} should be recalculated after update") if result[pillar]: self.assertIn('god', result[pillar], f"Updated {pillar} pillar missing 'god' field") self.assertIn('earth', result[pillar], f"Updated {pillar} pillar missing 'earth' field") # CRITICAL: Test that key fields are not null after update (this was the recent issue) critical_fields = ['god', 'earth', 'god_idx', 'earth_idx'] for field in critical_fields: self.assertIsNotNone( result[pillar][field], f"CRITICAL: Updated {pillar}.{field} must not be null - this was causing the recent issue" ) # Test that string fields are not empty after update self.assertNotEqual(result[pillar]['god'], "", f"Updated {pillar}.god should not be empty string") self.assertNotEqual(result[pillar]['earth'], "", f"Updated {pillar}.earth should not be empty string") # Check that sha_gods are recalculated self.assertIsNotNone(result['sha_gods'], "sha_gods should be recalculated after update") # Check that sha_god_locations are recalculated self.assertIsNotNone(result['sha_god_locations'], "sha_god_locations should be recalculated after update") # CRITICAL: Test that bazi_result is still populated after update self.assertIsNotNone(result['bazi_result'], "bazi_result must not be null after update") if result['bazi_result']: for pillar in ['year', 'month', 'day', 'hour']: self.assertIn(pillar, result['bazi_result'], f"bazi_result[{pillar}] missing after update") pillar_data = result['bazi_result'][pillar] self.assertIsNotNone(pillar_data, f"bazi_result[{pillar}] must not be null after update") if pillar_data: self.assertIn('god', pillar_data, f"bazi_result[{pillar}].god missing after update") self.assertIn('earth', pillar_data, f"bazi_result[{pillar}].earth missing after update") self.assertIsNotNone(pillar_data['god'], f"bazi_result[{pillar}].god must not be null after update") self.assertIsNotNone(pillar_data['earth'], f"bazi_result[{pillar}].earth must not be null after update") # Verify the birth date actually changed self.assertNotEqual(initial_data['birth_date'], updated_data['birth_date'], "Birth date should change after update") def test_bazi_get_api_null_fields_handling(self): """Test that BaZi GET API properly handles null fields.""" # Create a person with minimal data (no birth time) person = Person.objects.create( name='NullTest', gender='N', birth_date=date(2000, 12, 25), birth_time=None, created_by=self.user ) # Calculate BaZi person.calculate_bazi() person.save() # Test the API url = reverse('api:bazi-detail', kwargs={'pk': person.id}) resp = self.client.get(url) self.assertEqual(resp.status_code, 200) data = resp.json() result = data['result'] # Test that required fields exist (even if null) required_fields = ['year', 'month', 'day', 'hour', 'sha_gods', 'sha_god_locations', 'life_number', 'life_palace', 'ten_year_fate', 'year_fate', 'current_year', 'current_10year', 'bazi_result', 'nominal_age', 'element_strengths'] for field in required_fields: self.assertIn(field, result, f"Required field '{field}' missing from result") # Test that some fields can be null but structure is maintained if result['hour'] is None: # Hour pillar can be null if no birth time pass # This is acceptable # Test that bazi_result is always populated self.assertIsNotNone(result['bazi_result'], "bazi_result should always be populated") if result['bazi_result']: self.assertIn('day', result['bazi_result'], "bazi_result should always have day pillar") self.assertIsNotNone(result['bazi_result']['day'], "Day pillar in bazi_result should not be null") def test_bazi_get_api_no_null_values_critical_fields(self): """Test that BaZi GET API returns NO NULL values for critical fields that were previously causing issues.""" # Create a person with complete birth data person = Person.objects.create( name='NoNullTest', gender='M', birth_date=date(1985, 6, 15), birth_time=time(15, 45), created_by=self.user ) # Calculate BaZi to ensure all fields are populated person.calculate_bazi() person.save() # Test the API url = reverse('api:bazi-detail', kwargs={'pk': person.id}) resp = self.client.get(url) self.assertEqual(resp.status_code, 200) data = resp.json() result = data['result'] # CRITICAL: These fields must NEVER be null after the recent fix critical_pillars = ['year', 'month', 'day', 'hour'] for pillar in critical_pillars: self.assertIsNotNone(result[pillar], f"CRITICAL: Pillar {pillar} must not be null") if result[pillar]: # Test that all critical pillar fields are populated critical_pillar_fields = ['god', 'earth', 'god_idx', 'earth_idx'] for field in critical_pillar_fields: self.assertIsNotNone( result[pillar][field], f"CRITICAL: {pillar}.{field} must not be null - this was causing the recent issue" ) # Test that string fields are not empty strings if field in ['god', 'earth']: self.assertNotEqual( result[pillar][field], "", f"CRITICAL: {pillar}.{field} must not be empty string" ) # CRITICAL: sha_gods must not be null self.assertIsNotNone(result['sha_gods'], "CRITICAL: sha_gods must not be null") # CRITICAL: sha_god_locations must not be null self.assertIsNotNone(result['sha_god_locations'], "CRITICAL: sha_god_locations must not be null") # CRITICAL: bazi_result must not be null and must have all pillars self.assertIsNotNone(result['bazi_result'], "CRITICAL: bazi_result must not be null") if result['bazi_result']: for pillar in critical_pillars: self.assertIn(pillar, result['bazi_result'], f"CRITICAL: bazi_result must have {pillar} pillar") pillar_data = result['bazi_result'][pillar] self.assertIsNotNone(pillar_data, f"CRITICAL: bazi_result[{pillar}] must not be null") # Test that bazi_result pillars have god and earth values if pillar_data: self.assertIn('god', pillar_data, f"CRITICAL: bazi_result[{pillar}] must have 'god' field") self.assertIn('earth', pillar_data, f"CRITICAL: bazi_result[{pillar}] must have 'earth' field") self.assertIsNotNone(pillar_data['god'], f"CRITICAL: bazi_result[{pillar}].god must not be null") self.assertIsNotNone(pillar_data['earth'], f"CRITICAL: bazi_result[{pillar}].earth must not be null") # Test that other important fields are not null important_fields = ['life_number', 'life_palace', 'nominal_age'] for field in important_fields: if field in result: # These fields can be null in some cases, but if they exist, they should have meaningful values if result[field] is not None: if isinstance(result[field], (int, float)): # Numeric fields should not be 0 or negative unless that's meaningful pass # Allow 0 and negative values as they might be meaningful elif isinstance(result[field], str): # String fields should not be empty self.assertNotEqual(result[field], "", f"Field {field} should not be empty string if present") def test_bazi_get_api_update_preserves_all_values(self): """Test that updating a BaZi record preserves all values and doesn't introduce nulls.""" # Create a person person = Person.objects.create( name='UpdatePreserveTest', gender='F', birth_date=date(1990, 3, 10), birth_time=time(12, 30), created_by=self.user ) # Calculate initial BaZi person.calculate_bazi() person.save() # Get initial response and capture all non-null values url = reverse('api:bazi-detail', kwargs={'pk': person.id}) initial_resp = self.client.get(url) self.assertEqual(initial_resp.status_code, 200) initial_data = initial_resp.json() # Store initial non-null values for comparison initial_non_null_values = {} result = initial_data['result'] # Collect all non-null values from pillars for pillar in ['year', 'month', 'day', 'hour']: if result[pillar]: initial_non_null_values[pillar] = {} for field, value in result[pillar].items(): if value is not None: initial_non_null_values[pillar][field] = value # Update the person (change birth date to trigger recalculation) person.birth_date = date(1992, 7, 22) person.save() # Get updated response updated_resp = self.client.get(url) self.assertEqual(updated_resp.status_code, 200) updated_data = updated_resp.json() # Verify that all previously non-null values are still non-null updated_result = updated_data['result'] for pillar, fields in initial_non_null_values.items(): self.assertIsNotNone(updated_result[pillar], f"Pillar {pillar} became null after update") if updated_result[pillar]: for field, initial_value in fields.items(): updated_value = updated_result[pillar].get(field) self.assertIsNotNone( updated_value, f"CRITICAL: {pillar}.{field} became null after update - this was the recent issue" ) # The value might change (due to different birth date), but it should not become null if isinstance(initial_value, (int, float)) and isinstance(updated_value, (int, float)): # Numeric values should remain in valid ranges if initial_value >= 0: self.assertGreaterEqual(updated_value, 0, f"{pillar}.{field} should not become negative") if initial_value <= 10: # Assuming indices are 0-10 self.assertLessEqual(updated_value, 11, f"{pillar}.{field} should not exceed valid range") # Verify that critical fields are still populated critical_fields = ['sha_gods', 'sha_god_locations', 'bazi_result'] for field in critical_fields: self.assertIsNotNone(updated_result[field], f"CRITICAL: {field} became null after update") # Verify that bazi_result still has all pillars if updated_result['bazi_result']: for pillar in ['year', 'month', 'day', 'hour']: self.assertIn(pillar, updated_result['bazi_result'], f"bazi_result[{pillar}] missing after update") pillar_data = updated_result['bazi_result'][pillar] self.assertIsNotNone(pillar_data, f"bazi_result[{pillar}] became null after update") if pillar_data: self.assertIn('god', pillar_data, f"bazi_result[{pillar}].god missing after update") self.assertIn('earth', pillar_data, f"bazi_result[{pillar}].earth missing after update") self.assertIsNotNone(pillar_data['god'], f"bazi_result[{pillar}].god became null after update") self.assertIsNotNone(pillar_data['earth'], f"bazi_result[{pillar}].earth became null after update")