def test_mark_alert_as_displayed(tmp_path):
opt = Options(tmp_path)
all_alerts = (InfoAlert.FAQ, InfoAlert.MULTIWORLD_FAQ)
for alert in all_alerts:
assert not opt.is_alert_displayed(alert)
opt.mark_alert_as_displayed(alert)
assert opt.is_alert_displayed(alert)
assert opt.displayed_alerts == set(all_alerts)
new_opt = Options(tmp_path)
new_opt.load_from_disk()
assert new_opt.displayed_alerts == set(all_alerts)
def test_delete_files_location(
tmpdir,
games_path_exist: bool,
backup_path_exist: bool,
):
# Setup
data_dir = Path(str(tmpdir.join("user_data_dir")))
options = Options(data_dir)
game_files = tmpdir.join("user_data_dir", "extracted_game")
if games_path_exist:
game_files.ensure_dir()
game_files.join("random.txt").write_text("yay", "utf-8")
backup_files = tmpdir.join("user_data_dir", "backup")
if backup_path_exist:
backup_files.ensure_dir()
backup_files.join("random.txt").write_text("yay", "utf-8")
# Run
simplified_patcher.delete_files_location(options)
# Assert
assert not game_files.exists()
assert not backup_files.exists()
def test_load_from_disk_first_failure(tmp_path, mocker):
persisted_result = MagicMock()
mocker.patch(
"randovania.interface_common.persisted_options.find_config_files",
autospec=True,
return_value=[
"[1]",
"[2]",
])
mock_get_persisted_options_from_data = mocker.patch(
"randovania.interface_common.persisted_options.get_persisted_options_from_data",
autospec=True,
side_effect=[
migration_lib.UnsupportedVersion(),
persisted_result,
])
option = Options(tmp_path)
option.load_from_persisted = MagicMock()
# Run
result = option.load_from_disk(True)
# Assert
assert result
option.load_from_persisted.assert_called_once_with(persisted_result, True)
mock_get_persisted_options_from_data.assert_has_calls([
call([1]),
call([2]),
])
def test_save_options(skip_qtbot, tmp_path, is_prime_multi):
options = Options(tmp_path)
games = [RandovaniaGame.METROID_PRIME]
if is_prime_multi:
games.append(RandovaniaGame.METROID_PRIME_ECHOES)
window = PrimeGameExportDialog(options, {}, "MyHash", True, games)
window.output_file_edit.setText("somewhere/game.iso")
if is_prime_multi:
skip_qtbot.mouseClick(window.echoes_models_check, QtCore.Qt.LeftButton)
window.echoes_file_edit.setText("somewhere/echoes.iso")
# Run
window.save_options()
# Assert
assert options.options_for_game(
RandovaniaGame.METROID_PRIME).output_directory == Path("somewhere")
if is_prime_multi:
assert options.options_for_game(
RandovaniaGame.METROID_PRIME).use_external_models == {
RandovaniaGame.METROID_PRIME_ECHOES
}
assert options.options_for_game(
RandovaniaGame.METROID_PRIME_ECHOES).input_path == Path(
"somewhere/echoes.iso")
def _default_online_interactions(skip_qtbot,
preset_manager) -> OnlineInteractions:
main_window = MagicMock()
parent = QtWidgets.QWidget()
skip_qtbot.add_widget(parent)
return OnlineInteractions(parent, preset_manager, MagicMock(), main_window,
Options(MagicMock()))
def test_reset_to_defaults():
# Create and test they're equal
blank = Options(MagicMock())
modified = Options(MagicMock())
assert blank._serialize_fields() == modified._serialize_fields()
# Modify and test they're different
with modified:
for field in randovania.interface_common.options._SERIALIZER_FOR_FIELD.keys():
# This cause weirdness in serializing it
if field != "last_changelog_displayed":
modified._set_field(field, getattr(modified, field))
assert blank._serialize_fields() != modified._serialize_fields()
# Reset and test they're the same
with modified:
modified.reset_to_defaults()
assert blank._serialize_fields() == modified._serialize_fields()
def test_save_options(skip_qtbot, tmp_path):
options = Options(tmp_path)
window = SuperMetroidGameExportDialog(options, {}, "MyHash", True, [])
window.output_file_edit.setText("somewhere/game.smc")
# Run
window.save_options()
# Assert
assert options.options_for_game(
RandovaniaGame.SUPER_METROID).output_directory == Path("somewhere")
def test_setting_fields_to_self_do_nothing():
options = Options(MagicMock())
initial_serialize = options._serialize_fields()
# Modify and test they're different
with options:
for field in randovania.interface_common.options._SERIALIZER_FOR_FIELD.keys():
setattr(options, field, getattr(options, field))
# Reset and test they're the same
assert options._serialize_fields() == initial_serialize
def test_load_from_disk_missing_json(ignore_decode_errors: bool, tmpdir):
# Setup
option = Options(Path(tmpdir))
tmpdir.join("config.json").write_text("", "utf-8")
if ignore_decode_errors:
result = option.load_from_disk(ignore_decode_errors)
assert result != ignore_decode_errors
else:
with pytest.raises(DecodeFailedException):
option.load_from_disk(ignore_decode_errors)
def test_save_options(skip_qtbot, tmp_path):
options = Options(tmp_path)
window = CSGameExportDialog(options, {}, "MyHash", True, [])
window.output_file_edit.setText("somewhere/foo")
# Run
window.save_options()
# Assert
assert options.options_for_game(
RandovaniaGame.CAVE_STORY).output_directory == Path("somewhere/foo")
def test_edit_during_options_changed(tmpdir):
# Setup
option = Options(Path(tmpdir))
option._selected_tracker = "start"
def on_changed():
with option:
option.selected_tracker = "final"
option.on_options_changed = on_changed
# Run
with option:
option.selected_tracker = "middle"
second_option = Options(Path(tmpdir))
second_option.load_from_disk()
# Assert
assert option.selected_tracker == "final"
assert option.selected_tracker == second_option.selected_tracker
def test_edit_during_options_changed(tmpdir):
# Setup
option = Options(Path(tmpdir))
option._output_directory = Path("start")
def on_changed():
with option:
option.output_directory = Path("final")
option.on_options_changed = on_changed
# Run
with option:
option.output_directory = Path("middle")
second_option = Options(Path(tmpdir))
second_option.load_from_disk()
# Assert
assert option.output_directory == Path("final")
assert option.output_directory == second_option.output_directory
def test_load_from_disk_no_data(tmp_path, mocker):
# Setup
mock_get_persisted_options_from_data: MagicMock = mocker.patch(
"randovania.interface_common.persisted_options.get_persisted_options_from_data",
autospec=True)
option = Options(tmp_path)
# Run
option.load_from_disk()
# Assert
mock_get_persisted_options_from_data.assert_not_called()
def test_save_options(skip_qtbot, tmp_path):
options = Options(tmp_path)
window = DreadGameExportDialog(options, {}, "MyHash", True, [])
window.atmosphere_radio.setChecked(True)
# Run
window.save_options()
# Assert
game_options = options.options_for_game(RandovaniaGame.METROID_DREAD)
assert isinstance(game_options, DreadPerGameOptions)
assert game_options.target_platform == DreadModPlatform.ATMOSPHERE
def test_load_from_disk_invalid_json(ignore_decode_errors: bool, tmpdir):
# Setup
option = Options(Path(tmpdir))
tmpdir.join("config.json").write_text(
json.dumps(
randovania.interface_common.persisted_options.
serialized_data_for_options(
{"cosmetic_patches": {
"pickup_model_style": "invalid-value"
}})), "utf-8")
if ignore_decode_errors:
result = option.load_from_disk(ignore_decode_errors)
assert result != ignore_decode_errors
else:
with pytest.raises(DecodeFailedException):
option.load_from_disk(ignore_decode_errors)
def test_load_from_disk_with_data(fields_to_test: list[str], tmp_path, mocker):
# Setup
mock_get_persisted_options_from_data: MagicMock = mocker.patch(
"randovania.interface_common.persisted_options.get_persisted_options_from_data",
autospec=True)
mock_set_field: MagicMock = mocker.patch(
"randovania.interface_common.options.Options._set_field",
autospec=True)
tmp_path.joinpath("config.json").write_text("[1, 2, 54, 69]")
option = Options(tmp_path)
persisted_options = {
field_name: MagicMock()
for field_name in fields_to_test
}
new_serializers = {
field_name: MagicMock()
for field_name in fields_to_test
}
mock_get_persisted_options_from_data.return_value = persisted_options
# Run
with patch.dict(randovania.interface_common.options._SERIALIZER_FOR_FIELD,
new_serializers):
option.load_from_disk()
# Assert
mock_get_persisted_options_from_data.assert_called_once_with(
[1, 2, 54, 69])
for field_name, serializer in new_serializers.items():
serializer.decode.assert_called_once_with(
persisted_options[field_name])
mock_set_field.assert_has_calls([
call(option, field_name,
new_serializers[field_name].decode.return_value)
for field_name in fields_to_test
])
def test_load_from_disk_first_successful(tmp_path, mocker):
mocker.patch(
"randovania.interface_common.persisted_options.find_config_files",
autospec=True,
return_value=[
"[1]",
"[2]",
])
mock_get_persisted_options_from_data = mocker.patch(
"randovania.interface_common.persisted_options.get_persisted_options_from_data",
autospec=True,
)
option = Options(tmp_path)
option.load_from_persisted = MagicMock()
# Run
result = option.load_from_disk(False)
# Assert
assert result
option.load_from_persisted.assert_called_once_with(
mock_get_persisted_options_from_data.return_value, False)
mock_get_persisted_options_from_data.assert_called_once_with([1])
def test_click_on_preset_tree(tab, preset_manager, game: RandovaniaGame, skip_qtbot, tmp_path, allow_experimental):
preset = preset_manager.default_preset_for_game(game)
options = Options(tmp_path, None)
with options:
options.experimental_games = allow_experimental
options.on_options_changed = lambda: tab.on_options_changed(options)
tab._options = options
tab._window_manager.preset_manager = preset_manager
tab.setup_ui()
tab.on_options_changed(options)
# Run
item = tab.window.create_preset_tree.preset_to_item.get(preset.uuid)
# assert item.parent().text(0) == "1"
if not game.data.development_state.can_view(allow_experimental):
assert item is None
else:
tab.window.create_preset_tree.selectionModel().reset()
item.setSelected(True)
# Assert
assert tab._current_preset_data.get_preset() == preset.get_preset()
def _default_main_window(skip_qtbot, preset_manager) -> MainWindow:
return create_window(Options(MagicMock()), preset_manager)
def _default_main_window(skip_qtbot, preset_manager, mocker) -> MainWindow:
mocker.patch("randovania.gui.lib.theme.set_dark_theme")
return create_window(Options(MagicMock()), preset_manager)
def _option() -> Options:
return Options(MagicMock())
def _default_main_window() -> MainWindow:
return create_window(Options(MagicMock()))
