import json from pathlib import Path import tempfile import unittest from witcher_devkit import runner class ParticipantScopeTests(unittest.TestCase): @staticmethod def contact(attacker=2,victim=0,sequence=1,**fields): return dict(kind='contact',generation=7,sequence=sequence,contact_id=sequence, attacker=attacker,victim=victim,attempt_id=0,hp_before=100,hp_after=90,**fields) def test_player_dodge_requires_owned_attacker_and_player_victim(self): spec=dict(required_flags=['dodged'],flag_scope='incoming') for attacker,victim in [(98,99),(0,2),(98,0),(98,2),(2,3),(-1,0)]: with self.subTest(attacker=attacker,victim=victim): check=runner.assertions_result(spec,[self.contact(attacker,victim,dodged=True)],0,[2,3])[0] self.assertFalse(check['passed']) self.assertEqual(check['matched_events'],[]) event=self.contact(dodged=True) check=runner.assertions_result(spec,[event],0,[2])[0] self.assertTrue(check['passed']) self.assertEqual(check['matched_events'],[runner.event_reference(event)]) self.assertEqual(check['scope'],'incoming') def test_default_flags_exclude_world_events_and_outgoing_is_explicit(self): outside=self.contact(98,99,dodged=True) outgoing=self.contact(0,2,sequence=2,dodged=True) self.assertFalse(runner.assertions_result({'required_flags':['dodged']},[outside],0,[2])[0]['passed']) for scope in ('encounter','outgoing'): check=runner.assertions_result(dict(required_flags=['dodged'],flag_scope=scope),[outside,outgoing],0,[2])[0] self.assertTrue(check['passed']) self.assertEqual([e['sequence'] for e in check['matched_events']],[2]) def test_same_contact_mode_does_not_merge_flags_from_different_events(self): events=[self.contact(dodged=True),self.contact(sequence=2,attack={'parried':True})] spec=dict(required_flags=['dodged','parried'],flag_scope='incoming') self.assertTrue(all(c['passed'] for c in runner.assertions_result(spec,events,0,[2]))) spec['flag_match']='same_contact' self.assertFalse(runner.assertions_result(spec,events,0,[2])[0]['passed']) events.append(self.contact(sequence=3,dodged=True,attack={'parried':True})) check=runner.assertions_result(spec,events,0,[2])[0] self.assertTrue(check['passed']) self.assertEqual([e['sequence'] for e in check['matched_events']],[3]) def test_unknown_or_false_flags_do_not_pass(self): for fields in ({},{'dodged':None},{'dodged':False}): self.assertFalse(runner.assertions_result({'required_flags':['dodged']},[self.contact(**fields)],0,[2])[0]['passed']) def test_no_contacts_ignores_unrelated_fight_but_counts_encounter(self): world=[self.contact(98,99)] self.assertTrue(runner.assertions_result({'no_contacts':True},world,0,[2])[0]['passed']) for attacker,victim in [(0,2),(2,0)]: check=runner.assertions_result({'no_contacts':True},world+[self.contact(attacker,victim,sequence=2)],0,[2])[0] self.assertFalse(check['passed']) self.assertEqual(check['observed'],1) def test_external_contacts_to_either_side_retain_identity(self): for victim in (0,2): with self.subTest(victim=victim): summary=runner.summarize_events([self.contact(98,victim)],0,[2]) self.assertEqual(summary['environmental_interference'],[1]) detail=summary['interference_details'][0] self.assertEqual(detail['attacker'],98) self.assertEqual(detail['victim'],victim) self.assertEqual(detail['direction'],'external_to_participant') self.assertEqual(detail['contact_id'],1) def test_unknown_sources_and_external_causers_are_explicit(self): for attacker in (-1,None): summary=runner.summarize_events([self.contact(attacker,2)],0,[2]) self.assertEqual(summary['interference_details'][0]['attacker_role'],'unknown_or_nonactor') known=runner.summarize_events([self.contact(causer_actor=98)],0,[2]) self.assertEqual(known['interference_details'][0]['direction'],'external_causer') unknown=runner.summarize_events([self.contact(causer_actor=-1)],0,[2]) self.assertEqual(unknown['environmental_interference'],[]) def test_outbound_interference_and_unrelated_world_events(self): events=[self.contact(98,99),self.contact(0,98,sequence=2),self.contact(2,98,sequence=3)] summary=runner.summarize_events(events,0,[2]) self.assertEqual(summary['environmental_interference'],[2,3]) self.assertTrue(all(e['direction']=='participant_to_external' for e in summary['interference_details'])) self.assertEqual(runner.summarize_events([events[0]],0,[2])['environmental_interference'],[]) def test_participant_contacts_are_not_external_interference(self): events=[self.contact(0,2),self.contact(2,0,sequence=2),self.contact(2,3,sequence=3)] self.assertEqual(runner.summarize_events(events,0,[2,3])['environmental_interference'],[]) def test_plan_validates_scope_modes_and_rejects_unused_scope(self): plan=dict(fixture='save',trials=[dict(name='test',arena='0|0|0',enemy=dict(template='nekker',level=6),actions=[])]) for spec in (dict(required_flags=['dodged'],flag_scope='world'),dict(required_flags=['dodged'],flag_match='any'),dict(flag_scope='incoming'),dict(required_flags=[],flag_match='same_contact')): plan['trials'][0]['assertions']=spec with self.subTest(spec=spec),self.assertRaises(ValueError):runner.validate(plan) plan['trials'][0]['assertions']=dict(required_flags=['dodged'],flag_scope='incoming',flag_match='same_contact') self.assertEqual(runner.validate(plan),plan) class EvidenceTests(unittest.TestCase): def test_integrity_detects_changed_source_and_missing_evidence(self): with tempfile.TemporaryDirectory() as tmp: root=Path(tmp);original=root/'source.ws';original.write_text('original') copied=root/'copy.ws';copied.write_bytes(original.read_bytes()) manifest=root/'manifest.json';manifest.write_text(json.dumps({'files':[dict(path='copy.ws',sha256=runner.sha(copied),source_path=str(original))]})) self.assertTrue(runner.verify_evidence(manifest,True)['ok']) original.write_text('changed') self.assertTrue(runner.verify_evidence(manifest)['ok']) self.assertEqual(runner.verify_evidence(manifest,True)['failures'][0]['reason'],'current_source_differs') copied.unlink() self.assertEqual(runner.verify_evidence(manifest)['failures'][0]['reason'],'missing') def test_no_hit_is_not_zero_damage_contact(self): events=[dict(kind='attempt',attacker=0,attempt_id=1,tick=10)] summary=runner.summarize_events(events,0,[2]) self.assertEqual(summary['contacts'],0) self.assertEqual(summary['attempts_without_observed_contact'],[1]) checks=runner.assertions_result({'minimum_contacts':1,'health_channel':'essence'},events,0,[2]) self.assertFalse(any(c['passed'] for c in checks)) def test_overlap_counts_attackers_not_spawns(self): events=[dict(kind='attempt',attacker=i,attempt_id=n,tick=t) for n,(i,t) in enumerate([(2,0),(2,1),(3,15),(4,80)],1)] summary=runner.summarize_events(events,0,[2,3,4,5]) self.assertEqual(summary['spawn_count'],4) self.assertEqual(summary['attacking_enemy_ids'],[2,3,4]) self.assertEqual(summary['maximum_attackers_in_30_ticks'],2) def test_plan_rejects_unbounded_steps_and_unknown_mutations(self): plan=dict(fixture='save',trials=[dict(name='test',arena='0|0|0',enemy=dict(template='nekker',level=6),actions=[dict(advance=121)])]) with self.assertRaises(ValueError):runner.validate(plan) plan['trials'][0]['actions']=[dict(set_health=100)] with self.assertRaises(ValueError):runner.validate(plan) class RunnerLifecycleTests(unittest.TestCase): def test_runner_applies_participant_assertions_and_interference_validity(self): from contextlib import ExitStack from unittest.mock import patch from witcher_devkit import native, lifecycle cases=[ (ParticipantScopeTests.contact(dodged=True),'passed',True), (ParticipantScopeTests.contact(98,99,dodged=True),'failed',True), (ParticipantScopeTests.contact(98,2,dodged=True),'inconclusive',False), (ParticipantScopeTests.contact(-1,2,dodged=True),'inconclusive',False), ([ParticipantScopeTests.contact(dodged=True),ParticipantScopeTests.contact(98,2,sequence=2)],'inconclusive',False), ] for event,outcome,valid in cases: with self.subTest(event=event),tempfile.TemporaryDirectory() as tmp,ExitStack() as stack: root=Path(tmp) for folder in ('native','artifacts','mods','gamesaves','fixtures'):(root/folder).mkdir() (root/'gamesaves/fixture.sav').write_bytes(b'save') (root/'deployment.json').write_text('{}') (root/'fixtures/templates.json').write_text('{}') (root/'native/deployment.json').write_text('{"executable":{"sha256":"test"}}') plan=root/'plan.json' plan.write_text(json.dumps(dict(fixture='fixture',stop_after=False,trials=[dict( name='scope',arena='0|0|0',enemy=dict(template='nekker',level=6), actions=[dict(advance=1)],assertions=dict(required_flags=['dodged'],flag_scope='incoming'))]))) settings=dict(difficulty=4,upscaling=True,prototype_disabled=False,owned=[]) profiles={'profiles':[{'actor':{'id':0,'alive':True}},{'actor':{'id':2,'alive':True}}]} for obj,name,value in [(native,'ROOT',root),(native,'STATE_ROOT',root),(native.legacy,'ARTIFACTS',root/'artifacts'),(native.legacy.manage,'GAME',root),(native.legacy.manage,'DOCS',root)]: stack.enter_context(patch.object(obj,name,value)) for obj,name,value in [(native,'state',dict(session='s',build='b')),(lifecycle,'verify',{'ok':True}), (runner.lab,'require_paused',None),(runner.lab,'data',{'data':settings}), (native,'load',{'ok':True,'generation':7}),(runner.lab,'teleport',{'ok':True}), (runner.lab,'spawn',{'ok':True,'observed':profiles['profiles'][1:]}), (runner.lab,'profiles',profiles),(runner.lab,'snapshot',{}),(runner,'geometry',{}), (native,'bounded_action',{'ok':True,'after':{'data':{'world':{'player':{'alive':True}}}}})]: stack.enter_context(patch.object(obj,name,return_value=value)) events=event if isinstance(event,list) else [event] stack.enter_context(patch.object(runner.lab,'events',side_effect=[{'target_sequence':0},{'events':events,'next_cursor':len(events),'complete':True}])) result=runner.run(plan) report=json.loads(Path(result['result']).read_text()) trial=report['trials'][0] self.assertEqual(trial['outcome'],outcome) self.assertEqual(trial['experimental_validity'],valid) self.assertTrue(trial['command_success']) self.assertEqual(result['all_trials_passed'],outcome=='passed') if not valid: self.assertEqual(trial['reason'],'environmental_interference') self.assertEqual(trial['summary']['environmental_interference'],[events[-1]['sequence']]) if len(events)>1:self.assertTrue(all(c['passed'] for c in trial['assertions'])) compared=runner.comparisons({'trials':[ dict(name='scope',arena='0|0|0',enemy=dict(template='nekker',level=6),actions=[],declared_variable='enemy.level'), dict(name='other',arena='0|0|0',enemy=dict(template='nekker',level=12),actions=[],declared_variable='enemy.level') ]},[trial,dict(name='other',experimental_validity=True)],settings) self.assertFalse(compared[0]['observed_trials_valid']) self.assertTrue(runner.verify_evidence(result['manifest'])['ok']) def test_invalid_level_stops_actions_and_still_restores(self): from unittest.mock import patch import types from witcher_devkit import native, lifecycle with tempfile.TemporaryDirectory() as tmp: root=Path(tmp);(root/'native').mkdir();(root/'artifacts').mkdir();(root/'mods').mkdir();(root/'gamesaves').mkdir();(root/'fixtures').mkdir() self.enterContext(patch.object(native,'STATE_ROOT',root)) (root/'gamesaves'/'fixture.sav').write_bytes(b'save') (root/'deployment.json').write_text('{}') (root/'fixtures/templates.json').write_text('{}') (root/'native/deployment.json').write_text('{"executable": {"sha256": "test"}}') plan=root/'plan.json';plan.write_text(json.dumps(dict(fixture='fixture',repeats=2,stop_after=False,trials=[dict(name='invalid',arena='0|0|0',enemy=dict(template='wolf',level=6),actions=[dict(advance=1)])]))) settings=dict(difficulty=4,upscaling=True,prototype_disabled=False,owned=[]) with patch.object(native,'ROOT',root),patch.object(native.legacy,'ARTIFACTS',root/'artifacts'),patch.object(native.legacy.manage,'GAME',root),patch.object(native.legacy.manage,'DOCS',root),patch.object(native,'state',return_value=dict(session='s',build='b')),patch.object(lifecycle,'verify',return_value={'ok':True}),patch.object(runner.lab,'require_paused'),patch.object(runner.lab,'data',return_value={'data':settings}),patch.object(native,'load',return_value={'ok':True,'generation':1}) as load,patch.object(runner.lab,'teleport',return_value={'ok':True}),patch.object(runner.lab,'spawn',return_value={'ok':False,'outcome':'failed','reason':'actual_level_mismatch'}),patch.object(native,'bounded_action') as action: r=runner.run(plan) self.assertTrue(r['command_success']);self.assertFalse(r['all_trials_passed']) self.assertEqual(r['outcomes'],{'failed':2});action.assert_not_called() self.assertEqual(load.call_count,3) result=json.loads(Path(r['result']).read_text()) self.assertTrue(result['settings_restoration']['ok']) self.assertTrue(all(not t['experimental_validity'] for t in result['trials'])) self.assertTrue(runner.verify_evidence(r['manifest'])['ok']) def test_comparison_rejects_different_action_policy(self): first=dict(name='on',enemy=dict(template='nekker',level=6),arena='0|0|0',actions=[dict(advance=1)],declared_variable='prototype_disabled',settings={'prototype_disabled':False}) second={**first,'name':'off','settings':{'prototype_disabled':True},'actions':[dict(advance=2)]} r=runner.comparisons({'trials':[first,second]},[dict(name='on',experimental_validity=True),dict(name='off',experimental_validity=True)],{'prototype_disabled':False}) self.assertFalse(r[0]['one_declared_input_changed'])