Jellyfin/jellyfin-kodi
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin-kodi.git synced 2024-12-26 02:36:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

Mock dependencies instead of the function

Browse source
This commit is contained in:
Odd Stråbø 2024-08-09 18:24:38 +00:00
parent 6cde7a1141
commit d258f0d14c
2 changed files with 143 additions and 291 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
jellyfin_kodi/helper/playutils.py
View file

@ -363,11 +363,10 @@ class PlayUtils(object):
) )
def get_directplay_video_codec(self): def get_directplay_video_codec(self):
codecs = ["h264", "hevc", "h265", "mpeg4", "mpeg2video", "vc1", "vp9", "av1"] codecs = ["h264", "hevc", "mpeg4", "mpeg2video", "vc1", "vp9", "av1"]
if settings("transcode_h265.bool"): if settings("transcode_h265.bool"):
codecs.remove("hevc") codecs.remove("hevc")
codecs.remove("h265")
if settings("transcode_mpeg2.bool"): if settings("transcode_mpeg2.bool"):
codecs.remove("mpeg2video") codecs.remove("mpeg2video")
@ -387,7 +386,7 @@ class PlayUtils(object):
codecs = ["h264", "mpeg4", "mpeg2video", "vc1"] codecs = ["h264", "mpeg4", "mpeg2video", "vc1"]
if not settings("transcode_h265.bool"): if not settings("transcode_h265.bool"):
codecs.append("hevc") # Add HEVC if transcoding is not forced codecs.insert(1, "hevc") # Add HEVC if transcoding is not forced
if settings("videoPreferredCodec") == "H265/HEVC": if settings("videoPreferredCodec") == "H265/HEVC":
if "hevc" in codecs: if "hevc" in codecs:
@ -481,7 +480,7 @@ class PlayUtils(object):
profile["CodecProfiles"].append( profile["CodecProfiles"].append(
{ {
"Type": "Video", "Type": "Video",
"codec": "h265,hevc", "codec": "hevc",
"Conditions": [ "Conditions": [
{ {
"Condition": "EqualsAny", "Condition": "EqualsAny",

427
tests/test_playutils_settings.py
View file

@ -1,308 +1,213 @@
from unittest.mock import patch
import pytest import pytest
from jellyfin_kodi.helper import playutils
from jellyfin_kodi.helper.playutils import PlayUtils
@pytest.fixture @pytest.fixture
def mock_play_utils(): def play_utils():
with patch("jellyfin_kodi.helper.playutils.PlayUtils") as MockPlayUtils: class ApiClient:
mock_instance = MockPlayUtils.return_value class config:
mock_instance.get_transcoding_video_codec.return_value = "" data = {"auth.token": ""}
yield mock_instance
yield PlayUtils({}, api_client=ApiClient)
def test_hevc_transcoding_scenario(mock_play_utils): class PatchedSettings:
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: # TODO: move settings helper to separate file
# Scenario 1: Force Transcode enabled, Transcode HEVC disabled settings = {}
mock_settings.side_effect = [
True, # transcode_h265 = True (Transcode HEVC disabled)
"", # videoPreferredCodec = "" (no preference)
False, # transcode_mpeg2 = False
False, # transcode_vc1 = False
]
mock_play_utils.get_transcoding_video_codec.return_value = (
"h264,mpeg4,mpeg2video,vc1"
)
result_1 = mock_play_utils.get_transcoding_video_codec()
# Scenario 2: Force Transcode enabled, Transcode HEVC enabled def __init__(self):
mock_settings.side_effect = [ self.clear()
False, # transcode_h265 = False (Transcode HEVC enabled)
"", # videoPreferredCodec = "" (no preference)
False, # transcode_mpeg2 = False
False, # transcode_vc1 = False
]
mock_play_utils.get_transcoding_video_codec.return_value = (
"h264,mpeg4,mpeg2video,vc1,hevc"
)
result_2 = mock_play_utils.get_transcoding_video_codec()
# Assertions @classmethod
assert ( def __call__(cls, setting: str, value=None):
"hevc" not in result_1 if value is None:
), "HEVC should not be in codec list when Transcode HEVC is disabled" result = cls.settings[setting.replace(".bool", "")]
assert (
"hevc" in result_2
), "HEVC should be in codec list when Transcode HEVC is enabled"
# Ensure other codecs are present in both scenarios if result and setting.endswith(".bool"):
for codec in ["h264", "mpeg4", "mpeg2video", "vc1"]: result = result in ("true", "1", True)
assert (
codec in result_1
), f"{codec} should be in codec list regardless of HEVC setting"
assert (
codec in result_2
), f"{codec} should be in codec list regardless of HEVC setting"
# Ensure the order is correct in both scenarios return result
assert (
result_1 == "h264,mpeg4,mpeg2video,vc1" if setting.endswith(".bool"):
), "Codec order incorrect when HEVC is disabled" setting = setting.replace(".bool", "")
assert ( value = bool(value)
result_2 == "h264,mpeg4,mpeg2video,vc1,hevc" cls.settings[setting] = value
), "Codec order incorrect when HEVC is enabled"
@classmethod
def clear(cls):
cls.settings.clear()
# TODO: read defaults from settings.xml
cls.settings.setdefault("transcode_h265", False)
cls.settings.setdefault("videoPreferredCodec", "H264/AVC")
cls.settings.setdefault("transcode_mpeg2", False)
cls.settings.setdefault("transcode_vc1", False)
cls.settings.setdefault("audioPreferredCodec", "AAC")
cls.settings.setdefault("transcode_vp9", False)
cls.settings.setdefault("transcode_av1", False)
@pytest.fixture(autouse=True)
def mock_settings(monkeypatch):
patched = PatchedSettings()
monkeypatch.setattr(playutils, "settings", patched)
@pytest.mark.parametrize( @pytest.mark.parametrize(
"transcode_h265, preferred_codec, expected_result", "transcode_h265, preferred_codec, expected_result",
[ [
(False, "", "h264,mpeg4,mpeg2video,vc1,hevc"),
(True, "", "h264,mpeg4,mpeg2video,vc1"),
(False, "H265/HEVC", "hevc,h264,mpeg4,mpeg2video,vc1"), (False, "H265/HEVC", "hevc,h264,mpeg4,mpeg2video,vc1"),
(True, "H265/HEVC", "h264,mpeg4,mpeg2video,vc1"), (True, "H265/HEVC", "hevc,h264,mpeg4,mpeg2video,vc1"),
(False, "H264", "h264,mpeg4,mpeg2video,vc1,hevc"), (False, "H264/AVC", "h264,hevc,mpeg4,mpeg2video,vc1"),
(True, "H264", "h264,mpeg4,mpeg2video,vc1"), (True, "H264/AVC", "h264,mpeg4,mpeg2video,vc1"),
(False, "MPEG4", "mpeg4,h264,mpeg2video,vc1,hevc"),
(True, "MPEG4", "mpeg4,h264,mpeg2video,vc1"),
], ],
) )
def test_get_transcoding_video_codec_settings( def test_get_transcoding_video_codec_settings(
mock_play_utils, transcode_h265, preferred_codec, expected_result play_utils, transcode_h265, preferred_codec, expected_result
): ):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("transcode_h265", transcode_h265)
mock_settings.side_effect = [transcode_h265, preferred_codec] playutils.settings("videoPreferredCodec", preferred_codec)
mock_play_utils.get_transcoding_video_codec.return_value = expected_result
result = mock_play_utils.get_transcoding_video_codec() result = play_utils.get_transcoding_video_codec()
assert result == expected_result assert result == expected_result
@pytest.mark.parametrize( @pytest.mark.parametrize(
"transcode_mpeg2, transcode_vc1, expected_result", "transcode_mpeg2, transcode_vc1, expected_result",
[ [
(False, False, "h264,mpeg4,mpeg2video,vc1,hevc"), (False, False, "h264,hevc,mpeg4,mpeg2video,vc1"),
(True, False, "h264,mpeg4,vc1,hevc"), (True, False, "h264,hevc,mpeg4,vc1"),
(False, True, "h264,mpeg4,mpeg2video,hevc"), (False, True, "h264,hevc,mpeg4,mpeg2video"),
(True, True, "h264,mpeg4,hevc"), (True, True, "h264,hevc,mpeg4"),
], ],
) )
def test_get_transcoding_video_codec_transcode_options( def test_get_transcoding_video_codec_transcode_options(
mock_play_utils, transcode_mpeg2, transcode_vc1, expected_result play_utils, transcode_mpeg2, transcode_vc1, expected_result
): ):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("transcode_mpeg2", transcode_mpeg2)
mock_settings.side_effect = [False, "", transcode_mpeg2, transcode_vc1] playutils.settings("transcode_vc1", transcode_vc1)
mock_play_utils.get_transcoding_video_codec.return_value = expected_result result = play_utils.get_transcoding_video_codec()
result = mock_play_utils.get_transcoding_video_codec() assert result == expected_result
assert result == expected_result
@pytest.mark.parametrize( @pytest.mark.parametrize(
"preferred_codec, expected_first, expected_second", "preferred_codec, expected_first, expected_second",
[ [
("H265/HEVC", "hevc", "h264"), ("H265/HEVC", "hevc", "h264"),
("H264", "h264", "hevc"), ("H264/AVC", "h264", "hevc"),
("MPEG4", "mpeg4", "h264"),
], ],
) )
def test_get_transcoding_video_codec_order( def test_get_transcoding_video_codec_order(
mock_play_utils, preferred_codec, expected_first, expected_second play_utils, preferred_codec, expected_first, expected_second
): ):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("videoPreferredCodec", preferred_codec)
mock_settings.side_effect = [False, preferred_codec] result = play_utils.get_transcoding_video_codec().split(",")
mock_play_utils.get_transcoding_video_codec.return_value = ( assert result[0] == expected_first, result
f"{expected_first},{expected_second},mpeg2video,vc1" assert result[1] == expected_second, result
)
result = mock_play_utils.get_transcoding_video_codec()
assert result.startswith(expected_first)
assert expected_second in result
assert result.index(expected_first) < result.index(expected_second)
def test_get_transcoding_video_codec_no_duplicates(mock_play_utils): @pytest.mark.parametrize(
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: "preferred_codec, transcode_h265",
mock_settings.side_effect = [False, ""] [
mock_play_utils.get_transcoding_video_codec.return_value = ( ("H265/HEVC", True),
"h264,mpeg4,mpeg2video,vc1,hevc" ("H265/HEVC", False),
) ("H264/AVC", True),
result = mock_play_utils.get_transcoding_video_codec() ("H264/AVC", False),
assert result.count("hevc") == 1 ],
assert result.count("h264") == 1 )
assert result.count("mpeg4") == 1 def test_get_transcoding_video_codec_no_duplicates(
assert result.count("mpeg2video") == 1 play_utils, preferred_codec, transcode_h265
assert result.count("vc1") == 1 ):
playutils.settings("videoPreferredCodec", preferred_codec)
playutils.settings("transcode_h265", transcode_h265)
def test_get_transcoding_video_codec_empty_result(mock_play_utils): result = play_utils.get_transcoding_video_codec().split(",")
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: assert len(result) == len(set(result))
mock_settings.side_effect = [True, ""]
mock_play_utils.get_transcoding_video_codec.return_value = ""
result = mock_play_utils.get_transcoding_video_codec()
assert result == ""
def test_get_transcoding_video_codec_single_codec(mock_play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings:
mock_settings.side_effect = [True, "H264"]
mock_play_utils.get_transcoding_video_codec.return_value = "h264"
result = mock_play_utils.get_transcoding_video_codec()
assert result == "h264"
def test_get_transcoding_video_codec_unknown_preferred(mock_play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings:
mock_settings.side_effect = [False, "UNKNOWN"]
mock_play_utils.get_transcoding_video_codec.return_value = (
"h264,mpeg4,mpeg2video,vc1,hevc"
)
result = mock_play_utils.get_transcoding_video_codec()
assert result == "h264,mpeg4,mpeg2video,vc1,hevc"
@pytest.mark.parametrize( @pytest.mark.parametrize(
"transcode_h265, preferred_codec, transcode_mpeg2, transcode_vc1, expected_result", "transcode_h265, preferred_codec, transcode_mpeg2, transcode_vc1, expected_result",
[ [
(True, "H264", True, True, "h264,mpeg4"), (True, "H264/AVC", True, True, "h264,mpeg4"),
(False, "H265/HEVC", False, False, "hevc,h264,mpeg4,mpeg2video,vc1"), (False, "H265/HEVC", False, False, "hevc,h264,mpeg4,mpeg2video,vc1"),
(True, "MPEG4", True, False, "mpeg4,h264,vc1"),
], ],
) )
def test_get_transcoding_video_codec_combined_settings( def test_get_transcoding_video_codec_combined_settings(
mock_play_utils, play_utils,
transcode_h265, transcode_h265,
preferred_codec, preferred_codec,
transcode_mpeg2, transcode_mpeg2,
transcode_vc1, transcode_vc1,
expected_result, expected_result,
): ):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("transcode_h265", transcode_h265)
mock_settings.side_effect = [ playutils.settings("videoPreferredCodec", preferred_codec)
transcode_h265, playutils.settings("transcode_mpeg2", transcode_mpeg2)
preferred_codec, playutils.settings("transcode_vc1", transcode_vc1)
transcode_mpeg2,
transcode_vc1, result = play_utils.get_transcoding_video_codec()
] assert result == expected_result
mock_play_utils.get_transcoding_video_codec.return_value = expected_result
result = mock_play_utils.get_transcoding_video_codec()
assert result == expected_result
@pytest.mark.parametrize( @pytest.mark.parametrize(
"transcode_h265, preferred_codec, expected_result", "transcode_h265, expected_result",
[ [
(False, "", "h264,mpeg4,mpeg2video,vc1,hevc"), (False, "h264,hevc,mpeg4,mpeg2video,vc1,vp9,av1"),
(True, "", "h264,mpeg4,mpeg2video,vc1"), (True, "h264,mpeg4,mpeg2video,vc1,vp9,av1"),
(False, "H265/HEVC", "hevc,h264,mpeg4,mpeg2video,vc1"),
(True, "H265/HEVC", "h264,mpeg4,mpeg2video,vc1"),
(False, "H264", "h264,mpeg4,mpeg2video,vc1,hevc"),
(True, "H264", "h264,mpeg4,mpeg2video,vc1"),
(False, "MPEG4", "mpeg4,h264,mpeg2video,vc1,hevc"),
(True, "MPEG4", "mpeg4,h264,mpeg2video,vc1"),
], ],
) )
def test_get_directplay_video_codec( def test_get_directplay_video_codec(play_utils, transcode_h265, expected_result):
mock_play_utils, transcode_h265, preferred_codec, expected_result playutils.settings("transcode_h265", transcode_h265)
): result = play_utils.get_directplay_video_codec()
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: assert result == expected_result
mock_settings.side_effect = [transcode_h265, preferred_codec]
mock_play_utils.get_directplay_video_codec.return_value = expected_result
result = mock_play_utils.get_directplay_video_codec()
assert result == expected_result
@pytest.mark.parametrize( @pytest.mark.parametrize(
"transcode_mpeg2, transcode_vc1, expected_result", "transcode_mpeg2, transcode_vc1, expected_result",
[ [
(False, False, "h264,mpeg4,mpeg2video,vc1,hevc"), (False, False, "h264,hevc,mpeg4,mpeg2video,vc1,vp9,av1"),
(True, False, "h264,mpeg4,vc1,hevc"), (True, False, "h264,hevc,mpeg4,vc1,vp9,av1"),
(False, True, "h264,mpeg4,mpeg2video,hevc"), (False, True, "h264,hevc,mpeg4,mpeg2video,vp9,av1"),
(True, True, "h264,mpeg4,hevc"), (True, True, "h264,hevc,mpeg4,vp9,av1"),
], ],
) )
def test_get_directplay_video_codec_transcode_options( def test_get_directplay_video_codec_transcode_options(
mock_play_utils, transcode_mpeg2, transcode_vc1, expected_result play_utils, transcode_mpeg2, transcode_vc1, expected_result
): ):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("transcode_mpeg2", transcode_mpeg2)
mock_settings.side_effect = [False, "", transcode_mpeg2, transcode_vc1] playutils.settings("transcode_vc1", transcode_vc1)
mock_play_utils.get_directplay_video_codec.return_value = expected_result result = play_utils.get_directplay_video_codec()
result = mock_play_utils.get_directplay_video_codec() assert result == expected_result
assert result == expected_result
def test_get_directplay_video_codec_no_duplicates(mock_play_utils): def test_get_directplay_video_codec_no_duplicates(play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: result = play_utils.get_directplay_video_codec().split()
mock_settings.side_effect = [False, ""] assert len(result) == len(set(result))
mock_play_utils.get_directplay_video_codec.return_value = (
"h264,mpeg4,mpeg2video,vc1,hevc"
)
result = mock_play_utils.get_directplay_video_codec()
assert result.count("hevc") == 1
assert result.count("h264") == 1
assert result.count("mpeg4") == 1
assert result.count("mpeg2video") == 1
assert result.count("vc1") == 1
def test_get_directplay_video_codec_empty_result(mock_play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings:
mock_settings.side_effect = [True, ""]
mock_play_utils.get_directplay_video_codec.return_value = ""
result = mock_play_utils.get_directplay_video_codec()
assert result == ""
def test_get_directplay_video_codec_single_codec(mock_play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings:
mock_settings.side_effect = [True, "H264"]
mock_play_utils.get_directplay_video_codec.return_value = "h264"
result = mock_play_utils.get_directplay_video_codec()
assert result == "h264"
def test_get_directplay_video_codec_unknown_preferred(mock_play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings:
mock_settings.side_effect = [False, "UNKNOWN"]
mock_play_utils.get_directplay_video_codec.return_value = (
"h264,mpeg4,mpeg2video,vc1,hevc"
)
result = mock_play_utils.get_directplay_video_codec()
assert result == "h264,mpeg4,mpeg2video,vc1,hevc"
@pytest.mark.parametrize( @pytest.mark.parametrize(
"transcode_h265, preferred_codec, transcode_mpeg2, transcode_vc1, expected_result", "transcode_h265, transcode_mpeg2, transcode_vc1, transcode_vp9, transcode_av1, expected_result",
[ [
(True, "H264", True, True, "h264,mpeg4"), (True, True, True, True, True, "h264,mpeg4"),
(False, "H265/HEVC", False, False, "hevc,h264,mpeg4,mpeg2video,vc1"), (False, False, False, False, False, "h264,hevc,mpeg4,mpeg2video,vc1,vp9,av1"),
(True, "MPEG4", True, False, "mpeg4,h264,vc1"),
], ],
) )
def test_get_directplay_video_codec_combined_settings( def test_get_directplay_video_codec_combined_settings(
mock_play_utils, play_utils,
transcode_h265, transcode_h265,
preferred_codec,
transcode_mpeg2, transcode_mpeg2,
transcode_vc1, transcode_vc1,
transcode_vp9,
transcode_av1,
expected_result, expected_result,
): ):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("transcode_h265", transcode_h265)
mock_settings.side_effect = [ playutils.settings("transcode_mpeg2", transcode_mpeg2)
transcode_h265, playutils.settings("transcode_vc1", transcode_vc1)
preferred_codec, playutils.settings("transcode_vp9", transcode_vp9)
transcode_mpeg2, playutils.settings("transcode_av1", transcode_av1)
transcode_vc1, result = play_utils.get_directplay_video_codec()
] assert result == expected_result
mock_play_utils.get_directplay_video_codec.return_value = expected_result
result = mock_play_utils.get_directplay_video_codec()
assert result == expected_result
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -318,76 +223,24 @@ def test_get_directplay_video_codec_combined_settings(
("UNKNOWN", "aac,mp3,ac3,opus,flac,vorbis"), ("UNKNOWN", "aac,mp3,ac3,opus,flac,vorbis"),
], ],
) )
def test_get_transcoding_audio_codec(mock_play_utils, preferred_codec, expected_result): def test_get_transcoding_audio_codec(play_utils, preferred_codec, expected_result):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("audioPreferredCodec", preferred_codec)
mock_settings.return_value = preferred_codec result = play_utils.get_transcoding_audio_codec()
mock_play_utils.get_transcoding_audio_codec.return_value = expected_result assert result == expected_result
result = mock_play_utils.get_transcoding_audio_codec()
assert result == expected_result
def test_get_transcoding_audio_codec_case_insensitive(mock_play_utils): def test_get_transcoding_audio_codec_case_insensitive(play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("audioPreferredCodec", "aAc")
mock_settings.return_value = "aAc" result = play_utils.get_transcoding_audio_codec()
mock_play_utils.get_transcoding_audio_codec.return_value = ( assert result == "aac,mp3,ac3,opus,flac,vorbis"
"aac,mp3,ac3,opus,flac,vorbis"
)
result = mock_play_utils.get_transcoding_audio_codec()
assert result == "aac,mp3,ac3,opus,flac,vorbis"
def test_get_transcoding_audio_codec_no_duplicates(mock_play_utils): def test_get_transcoding_audio_codec_no_duplicates(play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: result = play_utils.get_transcoding_audio_codec().split(",")
mock_settings.return_value = "" assert len(result) == len(set(result))
mock_play_utils.get_transcoding_audio_codec.return_value = (
"aac,mp3,ac3,opus,flac,vorbis"
)
result = mock_play_utils.get_transcoding_audio_codec()
assert result.count("aac") == 1
assert result.count("mp3") == 1
assert result.count("ac3") == 1
assert result.count("opus") == 1
assert result.count("flac") == 1
assert result.count("vorbis") == 1
def test_get_transcoding_audio_codec_empty_result(mock_play_utils): def test_get_transcoding_audio_codec_preserve_order(play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings: playutils.settings("audioPreferredCodec", "")
mock_settings.return_value = "" result = play_utils.get_transcoding_audio_codec()
mock_play_utils.get_transcoding_audio_codec.return_value = "" assert result == "aac,mp3,ac3,opus,flac,vorbis"
result = mock_play_utils.get_transcoding_audio_codec()
assert result == ""
def test_get_transcoding_audio_codec_single_codec(mock_play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings:
mock_settings.return_value = "AAC"
mock_play_utils.get_transcoding_audio_codec.return_value = "aac"
result = mock_play_utils.get_transcoding_audio_codec()
assert result == "aac"
def test_get_transcoding_audio_codec_preserve_order(mock_play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings:
mock_settings.return_value = ""
mock_play_utils.get_transcoding_audio_codec.return_value = (
"aac,mp3,ac3,opus,flac,vorbis"
)
result = mock_play_utils.get_transcoding_audio_codec()
assert result == "aac,mp3,ac3,opus,flac,vorbis"
def test_get_transcoding_audio_codec_multiple_calls(mock_play_utils):
with patch("jellyfin_kodi.helper.playutils.settings") as mock_settings:
mock_settings.side_effect = ["AAC", "MP3", "FLAC"]
mock_play_utils.get_transcoding_audio_codec.side_effect = [
"aac,mp3,ac3,opus,flac,vorbis",
"mp3,aac,ac3,opus,flac,vorbis",
"flac,aac,mp3,ac3,opus,vorbis",
]
result1 = mock_play_utils.get_transcoding_audio_codec()
result2 = mock_play_utils.get_transcoding_audio_codec()
result3 = mock_play_utils.get_transcoding_audio_codec()
assert result1 == "aac,mp3,ac3,opus,flac,vorbis"
assert result2 == "mp3,aac,ac3,opus,flac,vorbis"
assert result3 == "flac,aac,mp3,ac3,opus,vorbis"