def _create_pickup_data(): resource_a = ItemResourceInfo(1, "A", "A", 10, None) resource_b = ItemResourceInfo(2, "B", "B", 10, None) return PickupEntry("Cake", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY, ( ConditionalResources("Sugar", None, ((resource_a, 1), )), ConditionalResources("Salt", resource_a, ((resource_b, 1), )), ))
def test_multi_create_pickup_data_for_self(pickup_for_create_pickup_data): # Setup solo = pickup_exporter.PickupExporterSolo( pickup_exporter.GenericAcquiredMemo()) creator = pickup_exporter.PickupExporterMulti( solo, MagicMock(), PlayersConfiguration(0, { 0: "You", 1: "Someone" })) model = MagicMock() resource_a = ItemResourceInfo(1, "A", "A", 10, None) resource_b = ItemResourceInfo(2, "B", "B", 10, None) # Run data = creator.create_details( PickupIndex(10), PickupTarget(pickup_for_create_pickup_data, 0), pickup_for_create_pickup_data, PickupModelStyle.ALL_VISIBLE, "Scan Text", model) # Assert assert data == pickup_exporter.ExportedPickupDetails( index=PickupIndex(10), scan_text="Your Scan Text", hud_text=['A acquired!', 'B acquired!'], conditional_resources=[ ConditionalResources("A", None, ((resource_a, 1), )), ConditionalResources("B", resource_a, ((resource_b, 1), )), ], conversion=[], model=model, )
def test_create_seeker_launcher( ammo_quantity: int, ammo_requires_major_item: bool, echoes_item_database, echoes_resource_database, ): # Setup missile = echoes_resource_database.get_item(44) missile_launcher = echoes_resource_database.get_item(73) seeker_launcher = echoes_resource_database.get_item(26) temporary = echoes_resource_database.get_item(71) state = MajorItemState( include_copy_in_original_location=False, num_shuffled_pickups=0, num_included_in_starting_items=0, included_ammo=(ammo_quantity, ), ) # Run result = randovania.generator.item_pool.pickup_creator.create_major_item( echoes_item_database.major_items["Seeker Launcher"], state, True, echoes_resource_database, echoes_item_database.ammo["Missile Expansion"], ammo_requires_major_item) # Assert locked_conditional = ( ConditionalResources("Seeker Launcher", None, resources=( (seeker_launcher, 1), (temporary, ammo_quantity), (echoes_resource_database.item_percentage, 1), )), ConditionalResources("Seeker Launcher", missile_launcher, resources=( (seeker_launcher, 1), (missile, ammo_quantity), (echoes_resource_database.item_percentage, 1), )), ) normal_resources = (ConditionalResources( "Seeker Launcher", None, resources=( (seeker_launcher, 1), (missile, ammo_quantity), (echoes_resource_database.item_percentage, 1), )), ) assert result == PickupEntry( name="Seeker Launcher", resources=locked_conditional if ammo_requires_major_item else normal_resources, model_index=25, item_category=ItemCategory.MISSILE, broad_category=ItemCategory.MISSILE_RELATED, )
def test_solo_create_pickup_data(pickup_for_create_pickup_data): # Setup creator = pickup_exporter.PickupExporterSolo(pickup_exporter.GenericAcquiredMemo()) model = MagicMock() resource_a = ItemResourceInfo(0, "A", "A", 10) resource_b = ItemResourceInfo(1, "B", "B", 10) # Run data = creator.create_details(PickupIndex(10), PickupTarget(pickup_for_create_pickup_data, 0), pickup_for_create_pickup_data, PickupModelStyle.ALL_VISIBLE, "Scan Text", model) # Assert assert data == pickup_exporter.ExportedPickupDetails( index=PickupIndex(10), scan_text="Scan Text", hud_text=['A acquired!', 'B acquired!'], conditional_resources=[ ConditionalResources("A", None, ((resource_a, 1),)), ConditionalResources("B", resource_a, ((resource_b, 1),)), ], conversion=[], model=model, other_player=False, original_pickup=pickup_for_create_pickup_data, )
def test_create_ammo_expansion(requires_major_item: bool, echoes_resource_database): # Setup primary_a = echoes_resource_database.get_by_type_and_index( ResourceType.ITEM, 73) ammo_a = echoes_resource_database.get_by_type_and_index( ResourceType.ITEM, 40) ammo_b = echoes_resource_database.get_by_type_and_index( ResourceType.ITEM, 42) temporary_a = echoes_resource_database.get_by_type_and_index( ResourceType.ITEM, 71) temporary_b = echoes_resource_database.get_by_type_and_index( ResourceType.ITEM, 72) ammo = Ammo( name="The Item", maximum=100, items=(40, 42), unlocked_by=73, temporaries=(71, 72), models=(10, 20), ) ammo_count = [75, 150] item_resources = ( (ammo_a, ammo_count[0]), (ammo_b, ammo_count[1]), (echoes_resource_database.item_percentage, 1), ) temporary_resources = ( (temporary_a, ammo_count[0]), (temporary_b, ammo_count[1]), (echoes_resource_database.item_percentage, 1), ) # Run result = randovania.generator.item_pool.pickup_creator.create_ammo_expansion( ammo, ammo_count, requires_major_item, echoes_resource_database) # Assert assert result == PickupEntry( name="The Item", model_index=10, resources=( ConditionalResources("Temporary Missile", None, temporary_resources), ConditionalResources("The Item", primary_a, item_resources), ) if requires_major_item else (ConditionalResources(None, None, item_resources), ), item_category=ItemCategory.EXPANSION, probability_offset=0, )
def create_details(self, original_index: PickupIndex, pickup_target: PickupTarget, visual_pickup: PickupEntry, model_style: PickupModelStyle, scan_text: str, model: PickupModel) -> ExportedPickupDetails: if pickup_target.player == self.players_config.player_index: details = self.solo_creator.create_details(original_index, pickup_target, visual_pickup, model_style, scan_text, model) return dataclasses.replace(details, scan_text=f"Your {details.scan_text}") else: other_name = self.players_config.player_names[pickup_target.player] return ExportedPickupDetails( index=original_index, scan_text=f"{other_name}'s {scan_text}", hud_text=[ f"Sent {pickup_target.pickup.name} to {other_name}!" ], conditional_resources=[ ConditionalResources( name=None, item=None, resources=((self.multiworld_item, original_index.index + 1), ), ) ], conversion=[], model=model, other_player=True, original_pickup=pickup_target.pickup, )
async def test_patches_for_pickup(backend, mocker): # Setup mock_item_patch: MagicMock = mocker.patch( "randovania.games.prime.all_prime_dol_patches.adjust_item_amount_and_capacity_patch") backend.patches = dol_patcher.ALL_VERSIONS_PATCHES[0] db = backend.game.resource_database pickup = PickupEntry("Pickup", 0, ItemCategory.MISSILE, ItemCategory.MISSILE, ( ConditionalResources(None, None, ((db.energy_tank, db.energy_tank.max_capacity), (db.item_percentage, 1)), ), )) backend._inventory = { db.multiworld_magic_item: InventoryItem(0, 0), db.energy_tank: InventoryItem(1, 1), } # Run patches, message = await backend._patches_for_pickup("Someone", pickup) # Assert mock_item_patch.assert_called_once_with(backend.patches.powerup_functions, db.energy_tank.index, db.energy_tank.max_capacity) assert patches == [mock_item_patch.return_value] assert message == "Received Pickup from Someone."
def _pickup() -> PickupEntry: return PickupEntry( name="Pickup", model_index=0, item_category=ItemCategory.MOVEMENT, resources=(ConditionalResources(None, None, ()), ), )
def test_run_validated_hud_text(): # Setup rng = MagicMock() rng.randint.return_value = 0 details = pickup_exporter.ExportedPickupDetails( index=PickupIndex(0), scan_text="scan", hud_text=["Energy Transfer Module acquired!"], conditional_resources=[ ConditionalResources(None, None, ()), ], conversion=[], model=PickupModel( game=RandovaniaGame.METROID_PRIME_ECHOES, name="EnergyTransferModule", ), other_player=False, original_pickup=None, ) # Run data = patch_data_factory.echoes_pickup_details_to_patcher(details, rng) # Assert assert data['hud_text'] == ['Run validated!']
def test_game_session_request_pickups_one_action( mock_session_description: PropertyMock, mock_get_resource_database: MagicMock, mock_get_pickup_target: MagicMock, flask_app, two_player_session, echoes_resource_database): # Setup sio = MagicMock() sio.get_current_user.return_value = database.User.get_by_id(1234) pickup = PickupEntry( "A", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY, (ConditionalResources(None, None, ((echoes_resource_database.item[0], 1), )), )) mock_get_pickup_target.return_value = PickupTarget(pickup=pickup, player=0) mock_get_resource_database.return_value = echoes_resource_database # Run result = game_session.game_session_request_pickups(sio, 1) # Assert mock_get_resource_database.assert_called_once_with( mock_session_description.return_value, 0) mock_get_pickup_target.assert_called_once_with( mock_session_description.return_value, 1, 0) assert result == [{'provider_name': 'Other Name', 'pickup': '6c8P51ON~'}]
def test_multi_create_pickup_data_for_other(pickup_for_create_pickup_data): # Setup multi = ItemResourceInfo(10, "Multiworld", "Multiworld", 30, None) solo = pickup_exporter.PickupExporterSolo( pickup_exporter.GenericAcquiredMemo()) creator = pickup_exporter.PickupExporterMulti( solo, multi, PlayersConfiguration(0, { 0: "You", 1: "Someone" })) model = MagicMock() resource_a = ItemResourceInfo(1, "A", "A", 10, None) resource_b = ItemResourceInfo(2, "B", "B", 10, None) # Run data = creator.create_details( PickupIndex(10), PickupTarget(pickup_for_create_pickup_data, 1), pickup_for_create_pickup_data, PickupModelStyle.ALL_VISIBLE, "Scan Text", model) # Assert assert data == pickup_exporter.ExportedPickupDetails( index=PickupIndex(10), scan_text="Someone's Scan Text", hud_text=['Sent Cake to Someone!'], conditional_resources=[ ConditionalResources(None, None, ((multi, 11), )), ], conversion=[], model=model, )
def test_game_session_collect_pickup_for_self( mock_session_description: PropertyMock, mock_get_resource_database: MagicMock, mock_get_pickup_target: MagicMock, mock_emit: MagicMock, flask_app, two_player_session, echoes_resource_database): sio = MagicMock() sio.get_current_user.return_value = database.User.get_by_id(1234) pickup = PickupEntry( "A", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY, (ConditionalResources(None, None, ((echoes_resource_database.item[0], 1), )), )) mock_get_resource_database.return_value = echoes_resource_database mock_get_pickup_target.return_value = PickupTarget(pickup, 0) # Run with flask_app.test_request_context(): result = game_session.game_session_collect_locations(sio, 1, (0, )) # Assert assert result is None mock_emit.assert_not_called() mock_get_pickup_target.assert_called_once_with( mock_session_description.return_value, 0, 0) with pytest.raises(peewee.DoesNotExist): database.GameSessionTeamAction.get(session=two_player_session, provider_row=0, provider_location_index=0)
def test_create_hints_item_dark_temple_keys(empty_patches, players_config, echoes_game_description, pickup, indices, expected_message): # Setup db = echoes_game_description.resource_database keys = [ (PickupIndex(index), dataclasses.replace(pickup, resources=(ConditionalResources( None, None, ((db.get_item(item), 1), )), ))) for index, item in zip(indices, echoes_items.DARK_TEMPLE_KEY_ITEMS[1]) ] patches = dataclasses.replace(empty_patches, pickup_assignment={ pickup_index: PickupTarget(key, 0) for pickup_index, key in keys }) hint = Hint(HintType.RED_TEMPLE_KEY_SET, None, dark_temple=HintDarkTemple.TORVUS_BOG) # Run result = item_hints.create_message_for_hint( hint, {0: patches}, players_config, None, {}, echoes_game_description.world_list) # Assert assert result == expected_message
def _make_pickup(item_category: ItemCategory): return PickupEntry( name="Pickup", model_index=0, item_category=item_category, broad_category=item_category, resources=(ConditionalResources(None, None, ()), ), )
def test_bit_pack_pickup_entry(has_convert: bool, echoes_resource_database): # Setup name = "Some Random Name" if has_convert: convert_resources = (ResourceConversion( find_resource_info_with_long_name(echoes_resource_database.item, "Morph Ball"), find_resource_info_with_long_name(echoes_resource_database.item, "Item Percentage")), ) else: convert_resources = () pickup = PickupEntry( name=name, model_index=26, item_category=ItemCategory.TEMPLE_KEY, broad_category=ItemCategory.KEY, resources=(ConditionalResources( "Morph Ball", None, ( (find_resource_info_with_long_name( echoes_resource_database.item, "Morph Ball"), 2), (find_resource_info_with_long_name( echoes_resource_database.item, "Item Percentage"), 5), ), ), ConditionalResources( "Grapple Beam", find_resource_info_with_long_name( echoes_resource_database.item, "Morph Ball"), ((find_resource_info_with_long_name( echoes_resource_database.item, "Grapple Beam"), 3), ), )), convert_resources=convert_resources) # Run encoded = bitpacking.pack_value( BitPackPickupEntry(pickup, echoes_resource_database)) decoder = BitPackDecoder(encoded) decoded = BitPackPickupEntry.bit_pack_unpack(decoder, name, echoes_resource_database) # Assert assert pickup == decoded
def bit_pack_unpack(cls, decoder: BitPackDecoder, name: str, database: ResourceDatabase) -> PickupEntry: model_index = decoder.decode_single(255) probability_offset = BitPackFloat.bit_pack_unpack( decoder, _PROBABILITY_OFFSET_META) probability_multiplier = BitPackFloat.bit_pack_unpack( decoder, _PROBABILITY_MULTIPLIER_META) item_category = ItemCategory.bit_pack_unpack(decoder, {}) broad_category = ItemCategory.bit_pack_unpack(decoder, {}) has_name = bitpacking.decode_bool(decoder) num_conditional = decoder.decode_single( MAXIMUM_PICKUP_CONDITIONAL_RESOURCES) + 1 conditional_resources = [] for i in range(num_conditional): item_name = None # TODO: get the first resource name if i > 0: item_dependency = decoder.decode_element(database.item) else: item_dependency = None resources = [] for _ in range(decoder.decode_single(MAXIMUM_PICKUP_RESOURCES + 1)): resource = decoder.decode_element(database.item) quantity = decoder.decode_single(255) resources.append((resource, quantity)) if has_name: if bitpacking.decode_bool(decoder): item_name = name else: item_name = resources[0][0].long_name conditional_resources.append( ConditionalResources( name=item_name, item=item_dependency, resources=tuple(resources), )) num_convert = decoder.decode_single(MAXIMUM_PICKUP_CONVERSION + 1) convert_resources = [] for i in range(num_convert): source = decoder.decode_element(database.item) target = decoder.decode_element(database.item) convert_resources.append(ResourceConversion(source, target)) return PickupEntry( name=name, model_index=model_index, item_category=item_category, broad_category=broad_category, resources=tuple(conditional_resources), convert_resources=tuple(convert_resources), probability_offset=probability_offset, probability_multiplier=probability_multiplier, )
def test_calculate_hud_text(order: Tuple[str, str]): # Setup resource_a = ItemResourceInfo(1, "A", "A", 10, None) resource_b = ItemResourceInfo(2, "B", "B", 10, None) pickup_x = PickupEntry("A", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY, (ConditionalResources("A", None, ((resource_a, 1), )), )) pickup_y = PickupEntry("Y", 2, ItemCategory.SUIT, ItemCategory.LIFE_SUPPORT, (ConditionalResources("B", None, ((resource_b, 1), )), ConditionalResources("A", resource_b, ((resource_a, 5), )))) pickup_z = PickupEntry("Z", 2, ItemCategory.SUIT, ItemCategory.LIFE_SUPPORT, (ConditionalResources("A", None, ((resource_a, 1), )), ConditionalResources("B", resource_a, ((resource_b, 5), )))) memo_data = { "A": "You got {A} of A", "B": "You found {B} of B", } pickups = { "X": pickup_x, "Y": pickup_y, "Z": pickup_z, } # Run result = patcher_file._calculate_hud_text(pickups[order[0]], pickups[order[1]], PickupModelStyle.HIDE_ALL, memo_data) # Assert if order[1] == "Y": assert result == ["You found 1 of B"] elif order[1] == "X": assert result == ["You got 1 of A", "You got 1 of A"] else: assert result == ["You got 1 of A", "You found 5 of B"]
def _pickup(echoes_game_description) -> PickupEntry: resource = echoes_game_description.resource_database.energy_tank return PickupEntry( name="Pickup", model_index=0, item_category=ItemCategory.MOVEMENT, broad_category=ItemCategory.LIFE_SUPPORT, resources=(ConditionalResources(None, None, ((resource, 2), )), ), )
def create_ammo_expansion( ammo: Ammo, ammo_count: List[int], requires_major_item: bool, resource_database: ResourceDatabase, ) -> PickupEntry: """ Creates a Pickup for an expansion of the given ammo. :param ammo: :param ammo_count: :param requires_major_item: :param resource_database: :return: """ resources = [(resource_database.get_item(item), count) for item, count in zip(ammo.items, ammo_count)] resources.append((resource_database.item_percentage, 1)) if ammo.unlocked_by is not None and requires_major_item: temporary_resources = [ (resource_database.get_item(item), count) for item, count in zip(ammo.temporaries, ammo_count) ] temporary_resources.append((resource_database.item_percentage, 1)) conditional_resources = ( ConditionalResources(temporary_resources[0][0].long_name, None, tuple(temporary_resources)), ConditionalResources(ammo.name, resource_database.get_item(ammo.unlocked_by), tuple(resources)), ) else: conditional_resources = (ConditionalResources(None, None, tuple(resources)), ) return PickupEntry( name=ammo.name, resources=conditional_resources, model_index=ammo.models[0], # TODO: use a random model item_category=ItemCategory.EXPANSION, broad_category=ammo.broad_category, )
def create_visual_etm() -> PickupEntry: """ Creates an ETM that should only be used as a visual pickup. :return: """ return PickupEntry( name="Unknown item", resources=(ConditionalResources(None, None, tuple()), ), model_index=USELESS_PICKUP_MODEL, item_category=ItemCategory.ETM, )
def test_add_pickup_to_state(database, patches): # Starting State s = state.State({}, (), 99, None, patches, None, database, None) resource_a = ItemResourceInfo(1, "A", "A", 10, None) resource_b = ItemResourceInfo(2, "B", "B", 10, None) p = PickupEntry("B", 2, ItemCategory.SUIT, ItemCategory.LIFE_SUPPORT, ( ConditionalResources(None, None, ((resource_a, 1), )), ConditionalResources(None, resource_a, ((resource_b, 1), )), )) # Run state.add_pickup_to_state(s, p) state.add_pickup_to_state(s, p) # Assert assert s.resources == { resource_a: 1, resource_b: 1, }
def test_add_pickup_to_state(database): # Starting State s = state.State({}, (), 99, None, None, None, database) resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM) resource_b = SimpleResourceInfo(2, "B", "B", ResourceType.ITEM) p = PickupEntry("B", 2, ItemCategory.SUIT, ( ConditionalResources(None, None, ((resource_a, 1), )), ConditionalResources(None, resource_a, ((resource_b, 1), )), )) # Run state.add_pickup_to_state(s, p) state.add_pickup_to_state(s, p) # Assert assert s.resources == { resource_a: 1, resource_b: 1, }
def test_prime1_pickup_details_to_patcher_shiny_missile( prime1_resource_database, other_player: bool): # Setup rng = MagicMock() rng.randint.return_value = 0 detail = pickup_exporter.ExportedPickupDetails( index=PickupIndex(15), scan_text="Your Missile Expansion. Provides 5 Missiles", hud_text=["Missile Expansion acquired!"], conditional_resources=[ ConditionalResources( None, None, ((prime1_resource_database.get_item_by_name("Missile"), 6), ), ) ], conversion=[], model=PickupModel(RandovaniaGame.METROID_PRIME, "Missile"), other_player=other_player, original_pickup=None, ) if other_player: shiny_stuff = { 'model': { 'game': 'prime1', 'name': 'Missile' }, 'scanText': 'Your Missile Expansion. Provides 5 Missiles', 'hudmemoText': 'Missile Expansion acquired!', } else: shiny_stuff = { 'model': { 'game': 'prime1', 'name': 'Shiny Missile' }, 'scanText': 'Your Shiny Missile Expansion. Provides 5 Missiles', 'hudmemoText': 'Shiny Missile Expansion acquired!', } # Run result = prime1_pickup_details_to_patcher(detail, False, rng) # Assert assert result == { 'type': 'Missile', 'currIncrease': 6, 'maxIncrease': 6, 'respawn': False, **shiny_stuff, }
def test_state_with_pickup(database, patches): # Setup starting = state.State({}, (), 99, None, patches, None, database, None) resource_a = ItemResourceInfo(1, "A", "A", 10, None) p = PickupEntry("A", 2, ItemCategory.SUIT, ItemCategory.LIFE_SUPPORT, (ConditionalResources(None, None, ((resource_a, 1), )), )) # Run final = state.state_with_pickup(starting, p) # Assert assert final.previous_state is starting assert final.resources == {resource_a: 1}
def test_state_with_pickup(database): # Setup starting = state.State({}, (), 99, None, None, None, database) resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM) p = PickupEntry("A", 2, ItemCategory.SUIT, (ConditionalResources(None, None, ((resource_a, 1), )), )) # Run final = state.state_with_pickup(starting, p) # Assert assert final.previous_state is starting assert final.resources == {resource_a: 1}
def create_useless_pickup(resource_database: ResourceDatabase) -> PickupEntry: """ Creates an Energy Transfer Module pickup. :param resource_database: :return: """ return PickupEntry( name="Energy Transfer Module", resources=(ConditionalResources( None, None, tuple([(resource_database.get_item(USELESS_PICKUP_ITEM), 1)])), ), model_index=USELESS_PICKUP_MODEL, item_category=ItemCategory.ETM, broad_category=ItemCategory.ETM, )
def _conditional_resources_for_pickup( pickup: PickupEntry) -> List[ConditionalResources]: if len(pickup.progression) > 1: assert pickup.resource_lock is None, pickup.name return list(pickup.conditional_resources) else: resources = list(pickup.extra_resources) name = pickup.name if pickup.progression: name = pickup.progression[0][0].long_name resources.append(pickup.progression[0]) lock = pickup.resource_lock if pickup.respects_lock and not pickup.unlocks_resource and lock is not None: locked_resources = lock.convert_gain(resources) return [ ConditionalResources( name=f"Locked {name}", item=None, resources=tuple(locked_resources), ), ConditionalResources( name=name, item=lock.locked_by, resources=tuple(resources), ), ] else: return [ ConditionalResources( name=name, item=None, resources=tuple(resources), ), ]
def create_artifact( artifact_index: int, resource_database: ResourceDatabase, ) -> PickupEntry: return PickupEntry( name=prime_items.ARTIFACT_NAMES[artifact_index], resources=(ConditionalResources( None, None, tuple([(resource_database.get_item( prime_items.ARTIFACT_ITEMS[artifact_index]), 1), (resource_database.item_percentage, 1)])), ), model_index=prime_items.ARTIFACT_MODEL[artifact_index], item_category=ItemCategory.TEMPLE_KEY, broad_category=ItemCategory.KEY, probability_offset=0.25, )
def test_decode_pickup(client, echoes_resource_database): data = b'\x00\xc8@\x00' expected_pickup = PickupEntry( name="", model_index=0, item_category=ItemCategory.MOVEMENT, broad_category=ItemCategory.MOVEMENT, resources=( ConditionalResources(None, None, ()), ), ) # Run pickup = client._decode_pickup(data) # Assert assert pickup == expected_pickup
def test_run_validated_hud_text(): # Setup rng = MagicMock() rng.randint.return_value = 0 creator = patcher_file.PickupCreatorSolo(rng, patcher_file._SimplifiedMemo()) resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM) pickup = PickupEntry("Energy Transfer Module", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY, ( ConditionalResources("Energy Transfer Module", None, ((resource_a, 1),)), )) # Run data = creator.create_pickup_data(PickupIndex(0), PickupTarget(pickup, 0), pickup, PickupModelStyle.ALL_VISIBLE, "Scan Text") # Assert assert data['hud_text'] == ['Run validated!']