morgan/Grinch-AP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Stardew Valley: Removed Pytest Requirement from everything (#1696)

Browse Source
This commit is contained in:
agilbert1412
2023-04-14 23:42:02 -04:00
committed by GitHub
parent d3baca9251
commit 3fdf07677c
4 changed files with 158 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

157
worlds/stardew_valley/test/TestOptions.py
View File

@@ -1,10 +1,9 @@
import itertools
import pytest
import unittest
from BaseClasses import ItemClassification, MultiWorld
from Options import SpecialRange
from . import setup_solo_multiworld
from . import setup_solo_multiworld, SVTestBase
from .. import StardewItem, options
from ..options import StardewOption, stardew_valley_option_classes
@@ -12,142 +11,138 @@ SEASONS = {"Spring", "Summer", "Fall", "Winter"}
TOOLS = {"Hoe", "Pickaxe", "Axe", "Watering Can", "Trash Can", "Fishing Rod"}
def basic_checks(multi_world: MultiWorld):
assert StardewItem("Victory", ItemClassification.progression, None, 1) in multi_world.get_items()
assert_can_win(multi_world)
assert len(multi_world.itempool) == len(
[location for location in multi_world.get_locations() if not location.event])
def assert_can_win(multiworld: MultiWorld):
for item in multiworld.get_items():
multiworld.state.collect(item)
assert multiworld.find_item("Victory", 1).can_reach(multiworld.state)
def assert_can_win(multi_world: MultiWorld):
for item in multi_world.get_items():
multi_world.state.collect(item)
assert multi_world.find_item("Victory", 1).can_reach(multi_world.state)
def basic_checks(multiworld: MultiWorld):
assert StardewItem("Victory", ItemClassification.progression, None, 1) in multiworld.get_items()
assert_can_win(multiworld)
assert len(multiworld.itempool) == len(
[location for location in multiworld.get_locations() if not location.event])
@pytest.mark.parametrize("option, value", [(option, value)
for option in stardew_valley_option_classes
if issubclass(option, SpecialRange)
for value in option.special_range_names])
def test_given_special_range_when_generate_then_basic_checks(option: (SpecialRange, StardewOption), value):
multi_world = setup_solo_multiworld({option.internal_name: option.special_range_names[value]})
class TestGenerateDynamicOptions(SVTestBase):
def test_given_special_range_when_generate_then_basic_checks(self):
for option in stardew_valley_option_classes:
if not issubclass(option, SpecialRange):
continue
with self.subTest(msg=option.internal_name):
for value in option.special_range_names:
multiworld = setup_solo_multiworld({option.internal_name: option.special_range_names[value]})
basic_checks(multiworld)
basic_checks(multi_world)
def test_given_choice_when_generate_then_basic_checks(self):
for option in stardew_valley_option_classes:
if not option.options:
continue
with self.subTest(msg=option.internal_name):
for value in option.options:
multiworld = setup_solo_multiworld({option.internal_name: option.options[value]})
basic_checks(multiworld)
def test_given_option_combination_when_generate_then_basic_checks(self):
option_combinations = [{options.Goal.internal_name: options.Goal.option_master_angler,
options.ToolProgression.internal_name: options.ToolProgression.option_vanilla}]
ids = ["Master Angler + Vanilla tools"]
for i in range(0, len(option_combinations)):
option_combination = option_combinations[i]
id = ids[i]
with self.subTest(msg=f"{id}"):
multi_world = setup_solo_multiworld(option_combination)
basic_checks(multi_world)
@pytest.mark.parametrize("option, value", [(option, value)
for option in stardew_valley_option_classes
if option.options
for value in option.options])
def test_given_choice_when_generate_then_basic_checks(option, value):
multi_world = setup_solo_multiworld({option.internal_name: option.options[value]})
basic_checks(multi_world)
@pytest.mark.parametrize("option_combination",
[{options.Goal.internal_name: options.Goal.option_master_angler,
options.ToolProgression.internal_name: options.ToolProgression.option_vanilla}],
ids=["Master Angler + Vanilla tools"])
def test_given_option_combination_when_generate_then_basic_checks(option_combination):
multi_world = setup_solo_multiworld(option_combination)
basic_checks(multi_world)
class TestGoal:
@pytest.mark.parametrize("goal,location", [("community_center", "Complete Community Center"),
class TestGoal(SVTestBase):
def test_given_goal_when_generate_then_victory_is_in_correct_location(self):
for goal, location in [("community_center", "Complete Community Center"),
("grandpa_evaluation", "Succeed Grandpa's Evaluation"),
("bottom_of_the_mines", "Reach the Bottom of The Mines"),
("cryptic_note", "Complete Quest Cryptic Note"),
("master_angler", "Catch Every Fish")])
def test_given_goal_when_generate_then_victory_is_in_correct_location(self, goal, location):
multi_world = setup_solo_multiworld({options.Goal.internal_name: options.Goal.options[goal]})
victory = multi_world.find_item("Victory", 1)
assert victory.name == location
("master_angler", "Catch Every Fish")]:
with self.subTest(msg=f"Goal: {goal}, Location: {location}"):
world_options = {options.Goal.internal_name: options.Goal.options[goal]}
multi_world = setup_solo_multiworld(world_options)
victory = multi_world.find_item("Victory", 1)
assert victory.name == location
class TestSeasonRandomization:
class TestSeasonRandomization(SVTestBase):
def test_given_disabled_when_generate_then_all_seasons_are_precollected(self):
multi_world = setup_solo_multiworld({options.SeasonRandomization.internal_name:
options.SeasonRandomization.option_disabled})
world_options = {options.SeasonRandomization.internal_name: options.SeasonRandomization.option_disabled}
multi_world = setup_solo_multiworld(world_options)
precollected_items = {item.name for item in multi_world.precollected_items[1]}
assert all([season in precollected_items for season in SEASONS])
@pytest.mark.parametrize("value", [value for value in options.SeasonRandomization.options if "randomized" in value])
def test_given_randomized_when_generate_then_all_seasons_are_in_the_pool_or_precollected(self, value):
multi_world = setup_solo_multiworld({options.SeasonRandomization.internal_name:
options.SeasonRandomization.options[value]})
def test_given_randomized_when_generate_then_all_seasons_are_in_the_pool_or_precollected(self):
world_options = {options.SeasonRandomization.internal_name: options.SeasonRandomization.option_randomized}
multi_world = setup_solo_multiworld(world_options)
precollected_items = {item.name for item in multi_world.precollected_items[1]}
items = {item.name for item in multi_world.get_items()} | precollected_items
assert all([season in items for season in SEASONS])
assert len(SEASONS.intersection(precollected_items)) == 1
def test_given_progressive_when_generate_then_3_progressive_seasons_are_in_the_pool(self):
multi_world = setup_solo_multiworld({options.SeasonRandomization.internal_name:
options.SeasonRandomization.option_progressive})
world_options = {options.SeasonRandomization.internal_name: options.SeasonRandomization.option_progressive}
multi_world = setup_solo_multiworld(world_options)
items = [item.name for item in multi_world.get_items()]
assert items.count("Progressive Season") == 3
class TestBackpackProgression:
class TestBackpackProgression(SVTestBase):
def test_given_vanilla_when_generate_then_no_backpack_in_pool(self):
multi_world = setup_solo_multiworld({options.BackpackProgression.internal_name:
options.BackpackProgression.option_vanilla})
world_options = {options.BackpackProgression.internal_name: options.BackpackProgression.option_vanilla}
multi_world = setup_solo_multiworld(world_options)
assert "Progressive Backpack" not in {item.name for item in multi_world.get_items()}
@pytest.mark.parametrize("value",
[value for value in options.BackpackProgression.options if "progressive" in value])
def test_given_progressive_when_generate_then_progressive_backpack_is_in_pool_two_times(self, value):
multi_world = setup_solo_multiworld({options.BackpackProgression.internal_name:
options.BackpackProgression.options[value]})
def test_given_progressive_when_generate_then_progressive_backpack_is_in_pool_two_times(self):
world_options = {options.BackpackProgression.internal_name: options.BackpackProgression.option_progressive}
multi_world = setup_solo_multiworld(world_options)
items = [item.name for item in multi_world.get_items()]
assert items.count("Progressive Backpack") == 2
@pytest.mark.parametrize("value",
[value for value in options.BackpackProgression.options if "progressive" in value])
def test_given_progressive_when_generate_then_backpack_upgrades_are_locations(self, value):
multi_world = setup_solo_multiworld({options.BackpackProgression.internal_name:
options.BackpackProgression.options[value]})
def test_given_progressive_when_generate_then_backpack_upgrades_are_locations(self):
world_options = {options.BackpackProgression.internal_name: options.BackpackProgression.option_progressive}
multi_world = setup_solo_multiworld(world_options)
locations = {locations.name for locations in multi_world.get_locations(1)}
assert "Large Pack" in locations
assert "Deluxe Pack" in locations
def test_given_early_progressive_when_generate_then_progressive_backpack_is_in_early_pool(self):
multi_world = setup_solo_multiworld({options.BackpackProgression.internal_name:
options.BackpackProgression.option_early_progressive})
world_options = {options.BackpackProgression.internal_name: options.BackpackProgression.option_early_progressive}
multi_world = setup_solo_multiworld(world_options)
assert "Progressive Backpack" in multi_world.early_items[1]
class TestToolProgression:
class TestToolProgression(SVTestBase):
def test_given_vanilla_when_generate_then_no_tool_in_pool(self):
multi_world = setup_solo_multiworld({options.ToolProgression.internal_name:
options.ToolProgression.option_vanilla})
world_options = {options.ToolProgression.internal_name: options.ToolProgression.option_vanilla}
multi_world = setup_solo_multiworld(world_options)
items = {item.name for item in multi_world.get_items()}
for tool in TOOLS:
assert tool not in items
def test_given_progressive_when_generate_then_progressive_tool_of_each_is_in_pool_four_times(self):
multi_world = setup_solo_multiworld({options.ToolProgression.internal_name:
options.ToolProgression.option_progressive})
world_options = {options.ToolProgression.internal_name:options.ToolProgression.option_progressive}
multi_world = setup_solo_multiworld(world_options)
items = [item.name for item in multi_world.get_items()]
for tool in TOOLS:
assert items.count("Progressive " + tool) == 4
def test_given_progressive_when_generate_then_tool_upgrades_are_locations(self):
multi_world = setup_solo_multiworld({options.ToolProgression.internal_name:
options.ToolProgression.option_progressive})
world_options = {options.ToolProgression.internal_name: options.ToolProgression.option_progressive}
multi_world = setup_solo_multiworld(world_options)
locations = {locations.name for locations in multi_world.get_locations(1)}
for material, tool in itertools.product(["Copper", "Iron", "Gold", "Iridium"],