Sansan/MusicPlayer
1
0 Fork 0
Code Issues 1 Pull Requests 1 Actions Packages Projects Releases 7 Wiki Activity
Files
feature/50-upload-soundtrack
MusicPlayer/tests/integration/test_continue_quiz.gd
T
SansanandClaude Opus 5.5 06421bb63e
Build / test (push) Successful in 1m50s
Details
Build / build (push) Successful in 1m14s
Details
Change soundtrack covers from the app and show the cover with the answer 
Cover menu in the soundtrack popup ("Change cover"):
- Choose picture uploads a JPEG, PNG or WebP picture (up to 10 MB).
- Pick by ID uses a game's cover on SteamGridDB or an anime's on AniList.
- Remove cover deletes it, so the server searches for a new one.
- The server's reason is shown when it refuses a change.
After a change the new cover time is fetched, and the popup, the
statistics card and the quiz show the new cover.

Quiz: once the answer is shown, the soundtrack's cover shows to the left of
the titles. Cover and titles are centered together, left and right and up
and down, and each title keeps to two lines. Cover times come from the
soundtrack list, and songs keep their soundtrack's UUID, also in saves.

Requests can now send any body with its content type, and every 2xx answer
counts as success. Cover frames are 2:3 like the server's covers. Small
copies of real covers are used by the tests and screenshots.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-14 23:32:09 +02:00

415 lines
15 KiB
GDScript
Raw Permalink Blame History

extends MainWindowTestSuite
## The quiz is saved after every change and goes on where it was when the game starts
## again: players, points, characters and songs, from the server or a music folder. A new
## game, a changed server playlist or a file that can't be read start over.
const SECOND_SONG: Dictionary = {"SongNo": 1, "Soundtrack": "Final Fantasy VI",
"Song": "Dancing Mad"}
var _mp3: PackedByteArray = FileAccess.get_file_as_bytes("res://tests/data/short.mp3")
func _saved() -> QuizSave:
# Saving waits until the end of the frame
await _runner.simulate_frames(1)
return QuizSave.read()
## Closes the game and starts it again, like the user does: everything in memory is gone
## and only the files are left. The server answers with [param server_songs] as its
## playlist, the songs it handed out before.
func _restart_game(server_songs: Array = SONG_INFO) -> void:
await _runner.simulate_frames(1)
_window.free()
Settings.player_array.clear()
Settings.music_folder = null
Settings.character_folder = ""
Settings.add_to_stats = true
Playlist.song_object_array.clear()
Playlist.currently_playing_song = -1
Playlist.latest_played_song = 0
Playlist.game_start_song = 0
Playlist.first_song_played = false
Playlist.is_song_downloading = false
Playlist._song_files_written = 0
_server.respond_json("/music/list", server_songs)
_server.requested_paths.clear()
_runner = scene_runner("res://main/MainWindow.tscn")
_window = _runner.scene()
_quiz = _window.get_node("Quiz")
await _runner.simulate_frames(3)
# Crono and Marle play the first song; Crono gets the point and the answer is shown. The
# second song is downloaded ahead.
func _play_a_little() -> Array[PlayerObject]:
var crono: PlayerObject = _add_player("Crono")
var marle: PlayerObject = _add_player("Marle")
_next_song_is(SECOND_SONG)
await _play_first_song()
await _give_point_with_keybind(1)
_press("SongControls/ShowAnswerButton")
await _runner.simulate_frames(2)
return [crono, marle]
func _now_playing() -> Array[String]:
var now_playing: Node = _quiz.get_node("NowPlaying")
return [(now_playing.get_node("Titles/SoundtrackLabel") as Label).text,
(now_playing.get_node("Titles/SongLabel") as Label).text]
# Saving
func test_players_points_and_songs_are_saved_as_the_quiz_goes_on() -> void:
var players: Array[PlayerObject] = await _play_a_little()
var saved: QuizSave = await _saved()
assert_array(saved.players.map(func(p: PlayerObject) -> String: return p.player_name)) \
.contains_exactly(["Crono", "Marle"])
assert_int(saved.players[0].player_score).is_equal(1)
assert_int(saved.songs.size()).is_equal(2)
assert_array(saved.songs[0].players_given_point).contains_exactly([players[0].id])
assert_bool(saved.songs[0].is_answered).is_true()
assert_bool(saved.songs[0].is_playing).is_true()
assert_bool(saved.songs[1].has_played).is_false()
assert_int(saved.currently_playing_song).is_equal(0)
func test_taking_a_point_is_saved() -> void:
await _play_a_little()
await _take_point_with_keybind(1)
var saved: QuizSave = await _saved()
assert_int(saved.players[0].player_score).is_equal(0)
assert_array(saved.songs[0].players_given_point).is_empty()
func test_picking_a_character_is_saved() -> void:
var crono: PlayerObject = _add_player("Crono")
_player_row(crono).change_character()
var texture: ImageTexture = ImageTexture.create_from_image(
Image.create(4, 4, false, Image.FORMAT_RGB8))
_quiz.character_select_popup.character_selected.emit(texture, "Frog.png")
assert_str((await _saved()).players[0].character_name).is_equal("Frog.png")
func test_removing_a_player_is_saved() -> void:
var players: Array[PlayerObject] = await _play_a_little()
await _remove_player(players[0])
var saved: QuizSave = await _saved()
assert_int(saved.players.size()).is_equal(1)
assert_array(saved.songs[0].players_given_point).is_empty()
func test_reset_points_saves_a_new_game() -> void:
await _play_a_little()
_press("QuizToolbar/ResetPointsButton")
var saved: QuizSave = await _saved()
assert_int(saved.players.size()).is_equal(2)
assert_int(saved.players[0].player_score).is_equal(0)
assert_array(saved.songs[0].players_given_point).is_empty()
assert_int(saved.game_start_song).is_equal(1)
func test_a_sync_saves_a_new_game() -> void:
await _play_a_little()
_quiz.on_sync_finished()
await _runner.simulate_frames(3)
var saved: QuizSave = await _saved()
assert_int(saved.players[0].player_score).is_equal(0)
assert_str(saved.players[0].player_name).is_equal("Crono")
func test_winning_is_saved_with_statistics_off() -> void:
Settings.winning_score = 1
await _play_a_little()
assert_bool((await _saved()).stats_paused_by_win).is_true()
# Continuing after a restart
func test_quiz_goes_on_after_a_restart() -> void:
var before: Array[PlayerObject] = await _play_a_little()
await _restart_game([SONG_INFO[0], SECOND_SONG])
assert_int(Settings.player_array.size()).is_equal(2)
var crono: PlayerObject = Settings.player_array[0]
assert_str(crono.player_name).is_equal("Crono")
assert_str(crono.id).is_equal(before[0].id)
assert_int(crono.player_score).is_equal(1)
assert_bool(crono.is_first_point).is_false()
assert_int(Playlist.song_object_array.size()).is_equal(2)
assert_array(Playlist.song_object_array[0].players_given_point).contains_exactly([crono.id])
assert_bool(Playlist.song_object_array[0].is_answered).is_true()
assert_bool(Playlist.song_object_array[1].has_played).is_false()
assert_int(Playlist.currently_playing_song).is_equal(0)
assert_array(_now_playing()).contains_exactly(["Chrono Trigger", "Corridors of Time"])
# The server's playlist was kept, not reset
assert_int(_server.count("/music/reset")).is_equal(0)
func test_players_rows_show_the_saved_scores() -> void:
await _play_a_little()
await _restart_game([SONG_INFO[0], SECOND_SONG])
var row: PlayerRow = _player_row(Settings.player_array[0])
assert_str(row.player_name_field.text).is_equal("Crono")
assert_str(row.score_label.text).is_equal("1")
func test_song_downloaded_ahead_is_kept_and_not_downloaded_again() -> void:
await _play_a_little()
var file: String = (await _saved()).songs[1].song_path
await _restart_game([SONG_INFO[0], SECOND_SONG])
assert_bool(FileAccess.file_exists(file)).is_true()
assert_int(_server.count("/music/rand")).is_equal(0)
assert_bool((_quiz.get_node("SongControls/NextButton") as Button).disabled).is_false()
func test_next_plays_the_song_downloaded_before_the_restart() -> void:
await _play_a_little()
await _restart_game([SONG_INFO[0], SECOND_SONG])
_press("SongControls/NextButton")
await await_millis(700)
assert_int(Playlist.currently_playing_song).is_equal(1)
assert_bool(_quiz.music_player.audio_player.playing).is_true()
func test_song_that_was_playing_is_ready_to_play_again() -> void:
await _play_a_little()
await _restart_game([SONG_INFO[0], SECOND_SONG])
var player: MusicPlayer = _quiz.music_player
assert_object(player.audio_player.stream).is_not_null()
assert_bool(player.audio_player.playing).is_false()
assert_bool(player.shows_playing()).is_false()
player.play_or_pause()
assert_bool(player.audio_player.playing).is_true()
func test_keybinds_give_points_after_a_restart() -> void:
await _play_a_little()
await _restart_game([SONG_INFO[0], SECOND_SONG])
await _give_point_with_keybind(2)
assert_array(_scores()).contains_exactly([1, 1])
assert_int((await _saved()).players[1].player_score).is_equal(1)
func test_song_files_that_are_gone_are_downloaded_again() -> void:
await _play_a_little()
var saved: QuizSave = await _saved()
for song_object: SongObject in saved.songs:
DirAccess.remove_absolute(song_object.song_path)
_server.respond_bytes("/music?song=0", _mp3)
_server.respond_bytes("/music?song=1", _mp3)
await _restart_game([SONG_INFO[0], SECOND_SONG])
# The song that was playing and the one downloaded ahead
assert_int(_server.count("/music?song=0")).is_equal(1)
assert_int(_server.count("/music?song=1")).is_equal(1)
assert_object(Playlist.get_song(1)).is_not_null()
func test_unused_song_files_are_deleted_at_start() -> void:
await _play_a_little()
var stray: String = Playlist.songs_folder().path_join("left_over.mp3")
FileAccess.open(stray, FileAccess.WRITE).store_buffer(_mp3)
await _restart_game([SONG_INFO[0], SECOND_SONG])
assert_bool(FileAccess.file_exists(stray)).is_false()
assert_int(DirAccess.get_files_at(Playlist.songs_folder()).size()).is_equal(2)
func test_changed_server_playlist_starts_over_with_the_same_players() -> void:
await _play_a_little()
# The server's playlist was reset, e.g. by a sync from another computer
await _restart_game([{"SongNo": 0, "Soundtrack": "Terranigma", "Song": "Underworld"}])
assert_array(Settings.player_array.map(func(p: PlayerObject) -> String:
return p.player_name)).contains_exactly(["Crono", "Marle"])
assert_array(_scores()).contains_exactly([0, 0])
assert_str(Playlist.song_object_array[0].soundtrack_title).is_equal("Terranigma")
assert_bool(Playlist.song_object_array[0].has_played).is_true()
func test_songs_the_server_added_after_the_save_are_kept_as_played() -> void:
await _play_a_little()
var third: Dictionary = {"SongNo": 2, "Soundtrack": "Terranigma", "Song": "Underworld"}
await _restart_game([SONG_INFO[0], SECOND_SONG, third])
assert_int(Playlist.song_object_array.size()).is_equal(3)
assert_int(Settings.player_array[0].player_score).is_equal(1)
assert_bool(Playlist.song_object_array[2].has_played).is_true()
func test_another_server_starts_over_with_the_same_players() -> void:
await _play_a_little()
var server_before: String = Settings.default_path
Settings.default_path = "https://other.example.com"
await _restart_game([SONG_INFO[0], SECOND_SONG])
Settings.default_path = server_before
assert_int(Settings.player_array.size()).is_equal(2)
assert_array(_scores()).contains_exactly([0, 0])
func test_file_that_cannot_be_read_starts_a_new_quiz() -> void:
await _play_a_little()
await _runner.simulate_frames(1)
FileAccess.open(QuizSave.path(), FileAccess.WRITE).store_string("{ half a fi")
await _restart_game([SONG_INFO[0], SECOND_SONG])
assert_array(Settings.player_array).is_empty()
# Like any start without a saved quiz: the server's songs count as played, and a new
# one is downloaded ahead
assert_bool(Playlist.song_object_array[0].has_played).is_true()
assert_bool(Playlist.song_object_array[1].has_played).is_true()
assert_int(Playlist.song_object_array.size()).is_equal(3)
# The broken file is replaced by the new quiz
assert_object(await _saved()).is_not_null()
func test_statistics_stay_off_after_a_won_game() -> void:
Settings.winning_score = 1
await _play_a_little()
await _restart_game([SONG_INFO[0], SECOND_SONG])
assert_bool(Settings.add_to_stats).is_false()
_press("QuizToolbar/ResetPointsButton")
assert_bool(Settings.add_to_stats).is_true()
func test_nothing_is_saved_before_the_saved_songs_are_back() -> void:
await _play_a_little()
_server.hold("/music/list")
await _restart_game([SONG_INFO[0], SECOND_SONG])
var file_before: String = FileAccess.get_file_as_string(QuizSave.path())
# A player added while the server has not answered yet
_add_player("Lucca")
await _runner.simulate_frames(2)
assert_str(FileAccess.get_file_as_string(QuizSave.path())).is_equal(file_before)
_server.release("/music/list")
await _runner.simulate_frames(2)
assert_int((await _saved()).players.size()).is_equal(3)
assert_int((await _saved()).songs.size()).is_equal(2)
# Characters
func test_character_picture_comes_back_after_a_restart() -> void:
var picture: Image = Image.create(20, 10, false, Image.FORMAT_RGB8)
_server.respond_bytes("/character?name=Frog.png", picture.save_png_to_buffer())
var crono: PlayerObject = _add_player("Crono")
_player_row(crono).new_character_selected(ImageTexture.create_from_image(picture),
"Frog.png")
_quiz.save_soon()
await _restart_game()
crono = Settings.player_array[0]
assert_str(crono.character_name).is_equal("Frog.png")
assert_vector(crono.character.get_size()).is_equal(Vector2(20, 10))
assert_object(_player_row(crono).character.texture_normal).is_same(crono.character)
func test_characters_from_a_folder_picked_for_the_session_are_reset_after_a_restart() -> void:
var folder: String = create_temp_dir("session_characters_%d" % randi())
FileAccess.open(folder.path_join("Santa.png"), FileAccess.WRITE).store_buffer(
Image.create(8, 4, false, Image.FORMAT_RGB8).save_png_to_buffer())
_window.settings_popup.use_character_folder(folder)
var crono: PlayerObject = _add_player("Crono")
_player_row(crono).new_character_selected(ImageTexture.create_from_image(
Image.create(8, 4, false, Image.FORMAT_RGB8)), "Santa.png")
_quiz.save_soon()
# The folder is only used until the game is closed
await _restart_game()
assert_str(Settings.player_array[0].character_name).is_empty()
assert_str(Settings.player_array[0].character.resource_path) \
.is_equal(PlayerObject.NO_CHARACTER_PATH)
# A music folder
func _prepared_quiz_folder() -> String:
var root: String = create_temp_dir("continue_offline_%d" % randi())
for file_name: String in ["01. Opening.mp3", "02. Jingle Bells.mp3", "03. Finale.mp3"]:
FileAccess.open(root.path_join(file_name), FileAccess.WRITE).store_buffer(_mp3)
return root
func test_quiz_from_a_music_folder_goes_on_offline() -> void:
var folder: String = _prepared_quiz_folder()
_window.settings_popup.use_music_folder(folder)
await _runner.simulate_frames(2)
_add_player("Crono")
_press("SongControls/NextButton")
await await_millis(700)
await _give_point_with_keybind(1)
await _restart_game()
assert_bool(Settings.is_offline()).is_true()
assert_str(Settings.music_folder.path).is_equal(folder)
assert_bool(_window.top_bar.offline_label.visible).is_true()
assert_int(Settings.player_array[0].player_score).is_equal(1)
assert_str(Playlist.song_object_array[0].song_title).is_equal("01. Opening")
assert_array(_server.requested_paths.filter(func(path: String) -> bool:
return path.begins_with("/music"))).is_empty()
_press("SongControls/NextButton")
await await_millis(700)
assert_str(Playlist.song_object_array[Playlist.currently_playing_song].song_title) \
.is_equal("02. Jingle Bells")
func test_music_folder_that_is_gone_starts_over_with_the_server() -> void:
var folder: String = _prepared_quiz_folder()
_window.settings_popup.use_music_folder(folder)
await _runner.simulate_frames(2)
_add_player("Crono")
_press("SongControls/NextButton")
await await_millis(700)
await _give_point_with_keybind(1)
for file_name: String in DirAccess.get_files_at(folder):
DirAccess.remove_absolute(folder.path_join(file_name))
await _restart_game()
assert_bool(Settings.is_offline()).is_false()
assert_int(Settings.player_array.size()).is_equal(1)
assert_array(_scores()).contains_exactly([0])
assert_str(Playlist.song_object_array[0].soundtrack_title).is_equal("Chrono Trigger")
Reference in new issue View Git Blame Copy Permalink