Migrate to project-based structure

1 files changed, 594 insertions, 0 deletions

diff --git a/solo-tool-project/test/solo_tool_integrationtest.py b/solo-tool-project/test/solo_tool_integrationtest.py
new file mode 100644
index 0000000..5903abf
--- /dev/null
+++ b/solo-tool-project/test/solo_tool_integrationtest.py
@@ -0,0 +1,594 @@
+import pathlib
+import shutil
+import pytest
+
+from solo_tool.solo_tool import SoloTool
+from player_mock import Player as MockPlayer
+
+@pytest.fixture
+def mockPlayer():
+    return MockPlayer()
+
+@pytest.fixture
+def uut(mockPlayer):
+    return SoloTool(mockPlayer)
+
+@pytest.fixture
+def prepared_tmp_path(tmp_path):
+    testFiles = [
+        "test.flac",
+        "test.mp3",
+        "test_session.json"
+    ]
+    for f in testFiles:
+        shutil.copy(pathlib.Path(f), tmp_path)
+
+    return tmp_path
+
+def checkLimit(uut, mockPlayer, aLimit, bLimit):
+    mockPlayer.position = bLimit - 0.1
+    uut.tick()
+    assert mockPlayer.position == bLimit - 0.1
+
+    mockPlayer.position = bLimit + 0.1
+    uut.tick()
+    assert mockPlayer.position == aLimit
+
+def test_playerControls(uut, mockPlayer):
+    assert mockPlayer.state == MockPlayer.STOPPED
+    assert uut.isPlaying() == False
+    uut.play()
+    assert mockPlayer.state == MockPlayer.PLAYING
+    assert uut.isPlaying() == True
+    uut.pause()
+    assert mockPlayer.state == MockPlayer.PAUSED
+    assert uut.isPlaying() == False
+    uut.stop()
+    assert mockPlayer.state == MockPlayer.STOPPED
+    assert uut.isPlaying() == False
+
+    assert mockPlayer.rate == 1.0
+    uut.setPlaybackRate(0.5)
+    assert mockPlayer.rate == 0.5
+
+    assert mockPlayer.position == 0.0
+    uut.setPlaybackPosition(0.5)
+    assert mockPlayer.position == 0.5
+
+    assert mockPlayer.volume == 1.0
+    uut.setPlaybackVolume(0.5)
+    assert mockPlayer.volume == 0.5
+
+def test_addAndSetSongs(uut, mockPlayer):
+    songs = [
+        "test.flac",
+        "test.mp3"
+    ]
+
+    for s in songs:
+        uut.addSong(s)
+    assert mockPlayer.currentSong == None
+    
+    for i, s in enumerate(songs):
+        uut.setSong(i)
+        assert mockPlayer.currentSong == songs[i]
+
+def test_nextAndPreviousSong(uut, mockPlayer):
+    songs = [
+        "test.flac",
+        "test.mp3"
+    ]
+    
+    for s in songs:
+        uut.addSong(s)
+    assert mockPlayer.currentSong == None
+    
+    uut.nextSong()
+    assert mockPlayer.currentSong == songs[0]
+    
+    uut.previousSong()
+    assert mockPlayer.currentSong == songs[0]
+
+    uut.nextSong()
+    assert mockPlayer.currentSong == songs[1]
+
+    uut.nextSong()
+    assert mockPlayer.currentSong == songs[1]
+
+def test_addAndSetAbLimits(uut, mockPlayer):
+    song = "test.flac"
+    abLimits = [
+        [0.2, 0.4],
+        [0.1, 0.3]
+    ]
+
+    uut.addSong(song)
+    uut.setSong(0)
+
+    for ab in abLimits:
+        uut.storeAbLimits(ab[0], ab[1])
+
+    mockPlayer.position = 0.0
+    uut.tick()
+    assert mockPlayer.position == 0.0
+
+    mockPlayer.position = 0.5
+    uut.tick()
+    assert mockPlayer.position == 0.5
+
+    uut.loadAbLimits(0)
+
+    uut.tick()
+    assert mockPlayer.position == 0.5
+
+    uut.setAbLimitEnable(True)
+
+    uut.tick()
+    assert mockPlayer.position == 0.2
+
+    uut.tick()
+    assert mockPlayer.position == 0.2
+
+    uut.loadAbLimits(1)
+    uut.tick()
+    assert mockPlayer.position == 0.2
+
+    mockPlayer.position = 0.8
+    uut.tick()
+    assert mockPlayer.position == 0.1
+
+def test_abLimitEnabledGetter(uut):
+    assert not uut.isAbLimitEnabled()
+
+    uut.setAbLimitEnable(True)
+    assert uut.isAbLimitEnabled()
+
+    uut.setAbLimitEnable(False)
+    assert not uut.isAbLimitEnabled()
+
+def test_multipleSongsAndAbLimits(uut, mockPlayer):
+    songs = [
+        "test.flac",
+        "test.mp3"
+    ]
+    abLimits = [
+        [0.2, 0.4],
+        [0.5, 0.7]
+    ]
+    
+    for s in songs:
+        uut.addSong(s)
+
+    for i, l in enumerate(abLimits):
+        uut.setSong(i)
+        uut.storeAbLimits(l[0], l[1])
+
+    uut.setAbLimitEnable(True)
+   
+    for i, l in enumerate(abLimits):
+        uut.setSong(i)
+        uut.loadAbLimits(0)
+
+        mockPlayer.position = l[0]
+        uut.tick()
+        assert mockPlayer.position == l[0]
+
+        mockPlayer.position = l[1] + 0.1
+        uut.tick()
+        assert mockPlayer.position == l[0]
+
+def test_storeAbLimitsWithoutSong(uut, mockPlayer):
+    song = "test.flac"
+    abLimit = [0.2, 0.4]
+    overflow = abLimit[1] + 0.1
+    default = 0.0
+    mockPlayer.position = overflow
+    uut.setAbLimitEnable(True)
+
+    uut.storeAbLimits(abLimit[0], abLimit[1])
+    uut.tick()
+    assert mockPlayer.position == default
+    mockPlayer.position = overflow
+    
+    uut.loadAbLimits(0)
+    uut.tick()
+    assert mockPlayer.position == default
+    mockPlayer.position = overflow
+
+    uut.addSong(song)
+    uut.tick()
+    assert mockPlayer.position == default
+    mockPlayer.position = overflow
+
+    uut.loadAbLimits(0)
+    uut.tick()
+    assert mockPlayer.position == default
+    mockPlayer.position = overflow
+
+    uut.setSong(0)
+    uut.tick()
+    assert mockPlayer.position == default
+    mockPlayer.position = overflow
+
+    uut.loadAbLimits(0)
+    uut.tick()
+    assert mockPlayer.position == default
+    mockPlayer.position = overflow
+
+    uut.storeAbLimits(abLimit[0], abLimit[1])
+    uut.tick()
+    assert mockPlayer.position == default
+    mockPlayer.position = overflow
+
+    uut.loadAbLimits(0)
+    uut.tick()
+    assert mockPlayer.position == abLimit[0]
+
+def test_nextAndPreviousAbLimit(uut, mockPlayer):
+    song = "test.flac"
+    abLimits = [
+        [0.2, 0.4],
+        [0.1, 0.3]
+    ]
+
+    uut.addSong(song)
+    uut.setSong(0)
+    uut.setAbLimitEnable(True)
+
+    for ab in abLimits:
+        uut.storeAbLimits(ab[0], ab[1])
+
+    checkLimit(uut, mockPlayer, 0.0, 0.0) # default limits 
+
+    uut.nextStoredAbLimits()
+    checkLimit(uut, mockPlayer, abLimits[0][0], abLimits[0][1])
+
+    uut.nextStoredAbLimits()
+    checkLimit(uut, mockPlayer, abLimits[1][0], abLimits[1][1])
+
+    uut.nextStoredAbLimits()
+    checkLimit(uut, mockPlayer, abLimits[1][0], abLimits[1][1])
+
+    uut.previousStoredAbLimits()
+    checkLimit(uut, mockPlayer, abLimits[0][0], abLimits[0][1])
+
+    uut.previousStoredAbLimits()
+    checkLimit(uut, mockPlayer, abLimits[0][0], abLimits[0][1])
+
+def test_abLimitsWhenChangingSongs(uut, mockPlayer):
+    songs = [
+        "test.flac",
+        "test.mp3"
+    ]
+    abLimits = [
+        [0.2, 0.4],
+        [0.1, 0.3],
+        [0.7, 0.8]
+    ]
+    uut.setAbLimitEnable(True)
+
+    for s in songs:
+        uut.addSong(s)
+
+    uut.setSong(0)
+    for ab in abLimits:
+        uut.storeAbLimits(ab[0], ab[1])
+
+    uut.setSong(1)
+    uut.storeAbLimits(abLimits[0][0], abLimits[0][1])
+
+    uut.setSong(0)
+    uut.loadAbLimits(len(abLimits) - 1)
+    checkLimit(uut, mockPlayer, abLimits[-1][0], abLimits[-1][1])
+
+    uut.setSong(1)
+    checkLimit(uut, mockPlayer, abLimits[-1][0], abLimits[-1][1])
+
+    uut.previousStoredAbLimits()
+    checkLimit(uut, mockPlayer, abLimits[0][0], abLimits[0][1])
+    
+def test_loadAndSaveSession(prepared_tmp_path):
+    mockPlayer = MockPlayer()
+    uut = SoloTool(mockPlayer)
+
+    loadedSessionFile = prepared_tmp_path / "test_session.json"
+    savedSessionFile = prepared_tmp_path / "test_session_save.json"
+
+    uut.loadSession(loadedSessionFile)
+    uut.saveSession(savedSessionFile)
+
+    import json
+    with open(loadedSessionFile, "r") as f:
+        loadedSession = json.loads(f.read())
+        
+    with open(savedSessionFile, "r") as f:
+        savedSession = json.loads(f.read())
+
+    assert loadedSession == savedSession
+
+def test_addInexistentFile(uut, mockPlayer):
+    song = "not/a/real/file"
+
+    uut.addSong(song)
+    uut.setSong(0)
+
+    assert mockPlayer.currentSong == None
+
+def test_getters(uut, mockPlayer):
+    song = "test.flac"
+    abLimit = [0.2, 0.4]
+
+    uut.addSong(song)
+    uut.setSong(0)
+    uut.storeAbLimits(abLimit[0], abLimit[1])
+
+    assert uut.getSongs() == [song]
+
+    limits = uut.getStoredAbLimits()
+    assert len(limits) == 1
+    assert limits[0][0] == abLimit[0]
+    assert limits[0][1] == abLimit[1]
+
+    mockPlayer.position = 0.8
+    assert uut.getPlaybackPosition() == 0.8
+
+    mockPlayer.volume = 0.8
+    assert uut.getPlaybackVolume() == 0.8
+
+    mockPlayer.rate = 0.5
+    assert uut.getPlaybackRate() == 0.5
+
+def test_setTemporaryLimits(uut, mockPlayer):
+    song = "test.flac"
+    abLimits = [
+        [0.2, 0.4],
+        [0.1, 0.4]
+    ]
+    overflow = 0.5
+
+    uut.setAbLimitEnable(True)
+    mockPlayer.position = overflow
+    uut.addSong(song)
+    uut.setSong(0)
+    uut.storeAbLimits(abLimits[0][0], abLimits[0][1])
+    uut.loadAbLimits(0)
+
+    uut.setAbLimits(abLimits[1][0], abLimits[1][1])
+    uut.tick()
+    assert mockPlayer.position == abLimits[1][0]
+
+def test_jumpToA(uut, mockPlayer):
+    abLimits = (0.2, 0.4)
+    initialPosition = 0.8
+
+    mockPlayer.position = initialPosition
+    
+    uut.jumpToA()
+    assert mockPlayer.position == 0.0 # default AB controller A limit
+
+    uut.setAbLimits(abLimits[0], abLimits[1])
+    uut.jumpToA()
+    assert mockPlayer.position == abLimits[0]
+
+def test_playingStateNotification(uut, mockPlayer):
+    song = "test.flac"
+    uut.addSong(song)
+    uut.setSong(0)
+
+    called = False
+    receivedValue = None
+    def callback(value):
+        nonlocal called, receivedValue
+        called = True
+        receivedValue = value
+
+    uut.registerPlayingStateCallback(callback)
+
+    assert mockPlayer.state == MockPlayer.STOPPED
+    assert not called
+
+    uut.play()
+    assert called
+    assert receivedValue == True
+    called = False
+    uut.play()
+    assert not called
+
+    uut.pause()
+    assert called
+    assert receivedValue == False
+    called = False
+    uut.pause()
+    assert not called
+
+    uut.play()
+    assert called
+    assert receivedValue == True
+    called = False
+
+    uut.stop()
+    assert called
+    assert receivedValue == False
+    called = False
+    uut.stop()
+    assert not called
+
+def test_playbackVolumeNotification(uut, mockPlayer):
+    song = "test.flac"
+    uut.addSong(song)
+    uut.setSong(0)
+
+    called = False
+    receivedValue = None
+    def callback(value):
+        nonlocal called, receivedValue
+        called = True
+        receivedValue = value
+
+    uut.registerPlaybackVolumeCallback(callback)
+
+    assert not called
+
+    uut.setPlaybackVolume(0.3)
+    assert called
+    assert receivedValue == 0.3
+    called = False
+
+    uut.setPlaybackVolume(0.3)
+    assert not called
+
+def test_playbackRateNotification(uut, mockPlayer):
+    song = "test.flac"
+    uut.addSong(song)
+    uut.setSong(0)
+
+    called = False
+    receivedValue = None
+    def callback(value):
+        nonlocal called, receivedValue
+        called = True
+        receivedValue = value
+
+    uut.registerPlaybackRateCallback(callback)
+
+    assert not called
+
+    uut.setPlaybackRate(0.5)
+    assert called
+    assert receivedValue == 0.5
+    called = False
+
+    uut.setPlaybackRate(0.5)
+    assert not called
+
+def test_currentSongNotification(uut):
+    called = False
+    receivedValue = None
+    def callback(value):
+        nonlocal called, receivedValue
+        called = True
+        receivedValue = value
+
+    uut.registerCurrentSongCallback(callback)
+    assert not called
+
+    songs = [
+        "test.flac",
+        "test.mp3"
+    ]
+    uut.addSong(songs[0])
+    assert not called
+
+    uut.setSong(0)
+    assert called
+    assert receivedValue == 0
+    called = False
+
+    uut.addSong(songs[1])
+    assert not called
+
+    uut.setSong(0)
+    assert not called
+
+    uut.setSong(1)
+    assert called
+    assert receivedValue == 1
+    called = False
+
+    uut.previousSong()
+    assert called
+    assert receivedValue == 0
+    called = False
+
+    uut.previousSong()
+    assert not called
+    
+    uut.nextSong()
+    assert called
+    assert receivedValue == 1
+    called = False
+
+    uut.nextSong()
+    assert not called
+
+def test_currentAbNotification(uut):
+    called = False
+    receivedValue = None
+    def callback(value):
+        nonlocal called, receivedValue
+        called = True
+        receivedValue = value
+
+    uut.registerCurrentAbLimitsCallback(callback)
+    assert not called
+
+    song = "test.flac"
+    uut.addSong(song)
+    uut.setSong(0)
+
+    abLimits = [
+        (0.2, 0.3),
+        (0.4, 0.5)
+    ]
+    uut.storeAbLimits(abLimits[0][0], abLimits[0][1])
+    assert not called
+    uut.storeAbLimits(abLimits[1][0], abLimits[1][1])
+    assert not called
+
+    uut.loadAbLimits(0)
+    assert called
+    assert receivedValue == 0
+    called = False
+
+    uut.loadAbLimits(0)
+    assert not called
+
+    uut.loadAbLimits(1)
+    assert called
+    assert receivedValue == 1
+    called = False
+
+    uut.previousStoredAbLimits()
+    assert called
+    assert receivedValue == 0
+    called = False
+
+    uut.previousStoredAbLimits()
+    assert not called
+    
+    uut.nextStoredAbLimits()
+    assert called
+    assert receivedValue == 1
+    called = False
+
+    uut.nextStoredAbLimits()
+    assert not called
+
+def test_abLimitEnabledNotification(uut):
+    called = False
+    receivedValue = None
+    def callback(value):
+        nonlocal called, receivedValue
+        called = True
+        receivedValue = value
+
+    uut.registerAbLimitEnabledCallback(callback)
+    assert not called
+
+    uut.setAbLimitEnable(False)
+    assert not called
+    assert receivedValue is None
+
+    uut.setAbLimitEnable(True)
+    assert called
+    assert receivedValue == True
+    called = False
+    receivedValue = None
+
+    uut.setAbLimitEnable(True)
+    assert not called
+    assert receivedValue is None
+
+    uut.setAbLimitEnable(False)
+    assert called
+    assert receivedValue == False