Refactor fixtures, introduce song pool argument

12 files changed, 145 insertions, 189 deletions

diff --git a/solo-tool-project/src/solo_tool/player_mpv.py b/solo-tool-project/src/solo_tool/player_mpv.py
index b9ab266..1297b63 100644
--- a/solo-tool-project/src/solo_tool/player_mpv.py
+++ b/solo-tool-project/src/solo_tool/player_mpv.py
@@ -41,7 +41,7 @@ class Player:
 
     def setCurrentSong(self, path):
         self.pause()
-        self._player.play(path)
+        self._player.play(str(path))
 
     def setPlayingStateChangedCallback(self, callback):
         self._playingStateCallback = callback
diff --git a/solo-tool-project/src/solo_tool/session_manager.py b/solo-tool-project/src/solo_tool/session_manager.py
index 9744b57..cd5ebf7 100644
--- a/solo-tool-project/src/solo_tool/session_manager.py
+++ b/solo-tool-project/src/solo_tool/session_manager.py
@@ -1,11 +1,11 @@
 import json
 from . import SoloTool
 
-def loadSession(file: str) -> SoloTool:
+def loadSession(file: str, songPool: str, player=None) -> SoloTool:
     with open(file, "r") as f:
         session = json.load(f)
 
-    st = SoloTool()
+    st = SoloTool(songPool, player=player)
 
     for i, entry in enumerate(session):
         songPath = entry["path"]
diff --git a/solo-tool-project/src/solo_tool/solo_tool.py b/solo-tool-project/src/solo_tool/solo_tool.py
index a55184e..349f3a0 100644
--- a/solo-tool-project/src/solo_tool/solo_tool.py
+++ b/solo-tool-project/src/solo_tool/solo_tool.py
@@ -1,10 +1,12 @@
 import os
+from pathlib import Path
 
 from .notifier import Notifier
 from .player_mpv import Player
 
 class SoloTool:
-    def __init__(self, player=None):
+    def __init__(self, songPool: str, player=None):
+        self._songPool = Path(songPool)
         self._player = Player() if player is None else player
         self._notifier = Notifier(self._player)
         self._songs = []
@@ -16,7 +18,7 @@ class SoloTool:
         previousSong = self._song
         self._song = index
         self._player.pause()
-        self._player.setCurrentSong(self._songs[index])
+        self._player.setCurrentSong(self._songPool / self._songs[index])
         self._notifier.notify(Notifier.CURRENT_SONG_EVENT, index)
 
         previousKp = self._keyPoint
@@ -35,12 +37,13 @@ class SoloTool:
     def songs(self) -> list[str]:
         return self._songs.copy()
 
-    def addSong(self, path: str) -> None:
+    def addSong(self, fileName: str) -> None:
+        path = self._songPool / fileName
         if not os.path.isfile(path):
             raise FileNotFoundError(path)
         if path in self._songs:
             return
-        self._songs.append(path)
+        self._songs.append(fileName)
         self._keyPoints.append([])
         self._notifier.notify(Notifier.SONG_LIST_EVENT, self.songs)
         if self.song is None:
diff --git a/solo-tool-project/test/fixtures.py b/solo-tool-project/test/fixtures.py
new file mode 100644
index 0000000..f70901b
--- /dev/null
+++ b/solo-tool-project/test/fixtures.py
@@ -0,0 +1,32 @@
+import pytest
+from pathlib import Path
+import os
+
+from solo_tool.solo_tool import SoloTool
+from player_mock import Player as MockPlayer
+
+@pytest.fixture
+def mockPlayer():
+    return MockPlayer()
+
+@pytest.fixture
+def songPool(tmp_path):
+    return tmp_path / "songs"
+
+@pytest.fixture
+def soloTool(mockPlayer, songPool):
+    return SoloTool(songPool, player=mockPlayer)
+
+@pytest.fixture
+def testSongs(songPool):
+    songs = [
+        songPool / "test.flac",
+        songPool / "test.mp3",
+        songPool / "test.mp4"
+    ]
+
+    os.mkdir(songPool)
+    for song in songs:
+        song.touch()
+    return songs
+
diff --git a/solo-tool-project/test/midi_launchpad_mini_integrationtest.py b/solo-tool-project/test/midi_launchpad_mini_integrationtest.py
index c731539..be8ed88 100644
--- a/solo-tool-project/test/midi_launchpad_mini_integrationtest.py
+++ b/solo-tool-project/test/midi_launchpad_mini_integrationtest.py
@@ -2,8 +2,7 @@ import pytest
 from mido import Message
 
 from solo_tool.midi_controller_launchpad_mini import MidiController
-from solo_tool.solo_tool import SoloTool
-from player_mock import Player as PlayerMock
+from fixtures import songPool, soloTool, mockPlayer, testSongs
 
 LED_RED = 3
 LED_YELLOW = 126
@@ -52,14 +51,6 @@ class MidiWrapperMock:
         return self.sentMessages[-1]
 
 @pytest.fixture
-def playerMock():
-    return PlayerMock()
-
-@pytest.fixture
-def soloTool(playerMock):
-    return SoloTool(playerMock)
-
-@pytest.fixture
 def midiWrapperMock():
     return MidiWrapperMock()
 
@@ -67,73 +58,70 @@ def midiWrapperMock():
 def uut(soloTool, midiWrapperMock):
     return MidiController(soloTool, midiWrapperMock)
 
-def test_startAndPauseButtons(uut, midiWrapperMock, playerMock):
+def test_startAndPauseButtons(uut, midiWrapperMock, mockPlayer):
     uut.connect()
 
-    assert not playerMock.playing
+    assert not mockPlayer.playing
     
     midiWrapperMock.simulateInput(playPauseButton)
-    assert playerMock.playing
+    assert mockPlayer.playing
     assert midiWrapperMock.getLatestMessage() == (playPauseButton, MidiController.LED_GREEN, 0)
 
     midiWrapperMock.simulateInput(playPauseButton)
-    assert not playerMock.playing
+    assert not mockPlayer.playing
     assert midiWrapperMock.getLatestMessage() == (playPauseButton, MidiController.LED_YELLOW, 0)
 
-def test_startPauseButtonLed(uut, midiWrapperMock, playerMock, soloTool):
+def test_startPauseButtonLed(uut, midiWrapperMock, mockPlayer, soloTool):
     uut.connect()
 
-    assert not playerMock.playing
+    assert not mockPlayer.playing
     
-    playerMock.playing = True
-    playerMock.simulatePlayingStateChanged()
+    mockPlayer.playing = True
+    mockPlayer.simulatePlayingStateChanged()
     assert midiWrapperMock.getLatestMessage() == (playPauseButton, MidiController.LED_GREEN, 0)
 
-    playerMock.playing = False
-    playerMock.simulatePlayingStateChanged()
+    mockPlayer.playing = False
+    mockPlayer.simulatePlayingStateChanged()
     assert midiWrapperMock.getLatestMessage() == (playPauseButton, MidiController.LED_YELLOW, 0)
 
-def test_jumpToKeyPositionButton(uut, midiWrapperMock, soloTool, playerMock):
-    soloTool.addSong("test.flac")
+def test_jumpToKeyPositionButton(uut, midiWrapperMock, soloTool, mockPlayer, testSongs):
+    soloTool.addSong(testSongs[0])
     uut.connect()
     
     soloTool.keyPoint = 0.5
-    assert playerMock.position == 0.0
+    assert mockPlayer.position == 0.0
 
     midiWrapperMock.simulateInput(jumpToKeyPositionButton)
-    assert playerMock.position == 0.5
+    assert mockPlayer.position == 0.5
 
 # TODO implement
-def test_jumpToStartButton(uut, midiWrapperMock, soloTool, playerMock):
+def test_jumpToStartButton(uut, midiWrapperMock, soloTool, mockPlayer):
     pass
 
-def test_previousAndNextSongButtons(uut, midiWrapperMock, soloTool, playerMock):
-    songs = [
-        "test.flac",
-        "test.mp3"
-    ]
-    for s in songs:
+def test_previousAndNextSongButtons(uut, midiWrapperMock, soloTool, mockPlayer, testSongs):
+    for s in testSongs:
         soloTool.addSong(s)
     uut.connect()
 
-    assert playerMock.currentSong == songs[0]
+    assert mockPlayer.currentSong == testSongs[0]
     midiWrapperMock.simulateInput(nextSongButton)
-    assert playerMock.currentSong == songs[1]
+    assert mockPlayer.currentSong == testSongs[1]
 
-    midiWrapperMock.simulateInput(nextSongButton)
-    assert playerMock.currentSong == songs[1]
+    for _ in testSongs:
+        midiWrapperMock.simulateInput(nextSongButton)
+    assert mockPlayer.currentSong == testSongs[-1]
 
     midiWrapperMock.simulateInput(previousSongButton)
-    assert playerMock.currentSong == songs[0]
+    assert mockPlayer.currentSong == testSongs[-2]
 
-    midiWrapperMock.simulateInput(previousSongButton)
-    assert playerMock.currentSong == songs[0]
+    for _ in testSongs:
+        midiWrapperMock.simulateInput(previousSongButton)
+    assert mockPlayer.currentSong == testSongs[0]
 
-def test_previousAndNextKeyPositionButtons(uut, midiWrapperMock, soloTool, playerMock):
-    song = "test.flac"
+def test_previousAndNextKeyPositionButtons(uut, midiWrapperMock, soloTool, mockPlayer, testSongs):
     keyPoints = [0.2, 0.1]
 
-    soloTool.addSong(song)
+    soloTool.addSong(testSongs[0])
     soloTool.keyPoints = keyPoints
 
     uut.connect()
@@ -152,7 +140,7 @@ def test_previousAndNextKeyPositionButtons(uut, midiWrapperMock, soloTool, playe
     midiWrapperMock.simulateInput(previousKeyPositionButton)
     assert soloTool.keyPoint == 0.1
 
-def test_playbackRateButtons(uut, midiWrapperMock, soloTool, playerMock):
+def test_playbackRateButtons(uut, midiWrapperMock, soloTool, mockPlayer):
     playbackRateOptions = {
         16 : (0.5, [LED_YELLOW] * 1 + [LED_OFF] * 7),
         17 : (0.6, [LED_YELLOW] * 2 + [LED_OFF] * 6),
@@ -164,18 +152,18 @@ def test_playbackRateButtons(uut, midiWrapperMock, soloTool, playerMock):
         23 : (1.2, [LED_YELLOW] * 8)
     }
     uut.connect()
-    assert playerMock.rate == 1.0
+    assert mockPlayer.rate == 1.0
 
     for t, button in enumerate(playbackRateOptions):
         midiWrapperMock.sentMessages.clear()
 
         midiWrapperMock.simulateInput(button)
-        assert playerMock.rate == playbackRateOptions[button][0]
+        assert mockPlayer.rate == playbackRateOptions[button][0]
 
         for i, colour in enumerate(playbackRateOptions[button][1]):
             assert midiWrapperMock.sentMessages[i] == (16 + i, colour, 0)
 
-def test_playbackRateLeds(uut, midiWrapperMock, soloTool, playerMock):
+def test_playbackRateLeds(uut, midiWrapperMock, soloTool, mockPlayer):
     playbackRateOptions = [
         (0.00, [LED_OFF] * 8),
         (0.49, [LED_OFF] * 8),
@@ -205,19 +193,19 @@ def test_playbackRateLeds(uut, midiWrapperMock, soloTool, playerMock):
         (1.5, [LED_YELLOW] * 8)
     ]
     uut.connect()
-    assert playerMock.rate == 1.0
+    assert mockPlayer.rate == 1.0
 
     for t, (rate, leds) in enumerate(playbackRateOptions):
         print(t)
         midiWrapperMock.sentMessages.clear()
 
         soloTool.rate = rate
-        assert playerMock.rate == rate
+        assert mockPlayer.rate == rate
 
         for i, colour in enumerate(leds):
             assert midiWrapperMock.sentMessages[i] == (16 + i, colour, 0)
 
-def test_playbackVolumeButtons(uut, midiWrapperMock, soloTool, playerMock):
+def test_playbackVolumeButtons(uut, midiWrapperMock, soloTool, mockPlayer):
     playbackVolumeOptions = {
         0 : (0.5, [LED_GREEN] * 1 + [LED_OFF] * 7),
         1 : (0.6, [LED_GREEN] * 2 + [LED_OFF] * 6),
@@ -229,18 +217,18 @@ def test_playbackVolumeButtons(uut, midiWrapperMock, soloTool, playerMock):
         7 : (1.2, [LED_GREEN] * 8)
     }
     uut.connect()
-    assert playerMock.volume == 1.0
+    assert mockPlayer.volume == 1.0
     
     for t, button in enumerate(playbackVolumeOptions):
         midiWrapperMock.sentMessages.clear()
 
         midiWrapperMock.simulateInput(button)
-        assert playerMock.volume == playbackVolumeOptions[button][0]
+        assert mockPlayer.volume == playbackVolumeOptions[button][0]
 
         for i, colour in enumerate(playbackVolumeOptions[button][1]):
             assert midiWrapperMock.sentMessages[i] == (i, colour, 0)
 
-def test_playbackVolumeLeds(uut, midiWrapperMock, soloTool, playerMock):
+def test_playbackVolumeLeds(uut, midiWrapperMock, soloTool, mockPlayer):
     playbackVolumeOptions = [
         (0.00, [LED_OFF] * 8),
         (0.49, [LED_OFF] * 8),
@@ -270,13 +258,13 @@ def test_playbackVolumeLeds(uut, midiWrapperMock, soloTool, playerMock):
         (1.5, [LED_GREEN] * 8)
     ]
     uut.connect()
-    assert playerMock.volume == 1.0
+    assert mockPlayer.volume == 1.0
 
     for t, (volume, leds) in enumerate(playbackVolumeOptions):
         midiWrapperMock.sentMessages.clear()
 
         soloTool.volume = volume
-        assert playerMock.volume == volume
+        assert mockPlayer.volume == volume
 
         for i, colour in enumerate(leds):
             assert midiWrapperMock.sentMessages[i] == (i, colour, 0)
@@ -325,73 +313,67 @@ def test_connectDisconnect(uut, midiWrapperMock):
 
     assert set(midiWrapperMock.sentMessages) == set(teardownMessages)
 
-def test_playingFeedbackWhenChangingSong(uut, midiWrapperMock, soloTool, playerMock):
-    songs = [
-        "test.flac",
-        "test.mp3"
-    ]
-    for s in songs:
+def test_playingFeedbackWhenChangingSong(uut, midiWrapperMock, soloTool, mockPlayer, testSongs):
+    for s in testSongs:
         soloTool.addSong(s)
     uut.connect()
 
     soloTool.play()
-    assert playerMock.playing
+    assert mockPlayer.playing
     assert midiWrapperMock.getLatestMessage() == (playPauseButton, LED_GREEN, 0)
 
     soloTool.song = 1
-    assert not playerMock.playing
+    assert not mockPlayer.playing
     assert midiWrapperMock.getLatestMessage() == (playPauseButton, LED_YELLOW, 0)
 
-def test_setKeyPositionButton(uut, midiWrapperMock, soloTool, playerMock):
-    song = "test.flac"
-    soloTool.addSong(song)
+def test_setKeyPositionButton(uut, midiWrapperMock, soloTool, mockPlayer, testSongs):
+    soloTool.addSong(testSongs[0])
 
     uut.connect()
 
-    playerMock.position = 0.3
+    mockPlayer.position = 0.3
     midiWrapperMock.simulateInput(setKeyPositionButton)
     assert soloTool.keyPoint == 0.3
 
-    playerMock.position = 0.5
+    mockPlayer.position = 0.5
     midiWrapperMock.simulateInput(setKeyPositionButton)
     assert soloTool.keyPoint == 0.5
 
-    playerMock.position = 0.7
+    mockPlayer.position = 0.7
     midiWrapperMock.simulateInput(jumpToKeyPositionButton)
-    assert playerMock.position == 0.5
+    assert mockPlayer.position == 0.5
 
-def test_seekButtons(uut, midiWrapperMock, soloTool, playerMock):
-    song = "test.flac"
-    soloTool.addSong(song)
+def test_seekButtons(uut, midiWrapperMock, soloTool, mockPlayer, testSongs):
+    soloTool.addSong(testSongs[0])
 
     uut.connect()
     
-    assert playerMock.position == 0.0
+    assert mockPlayer.position == 0.0
 
     midiWrapperMock.simulateInput(fwd25PcButton)
-    assert playerMock.position == 0.25
+    assert mockPlayer.position == 0.25
 
     midiWrapperMock.simulateInput(fwd5PcButton)
-    assert playerMock.position == 0.30
+    assert mockPlayer.position == 0.30
 
     midiWrapperMock.simulateInput(fwd1PcButton)
-    assert playerMock.position == 0.31
+    assert mockPlayer.position == 0.31
 
     midiWrapperMock.simulateInput(fwd25PcButton)
     midiWrapperMock.simulateInput(fwd25PcButton)
     midiWrapperMock.simulateInput(fwd25PcButton)
-    assert playerMock.position == 1.0
+    assert mockPlayer.position == 1.0
 
     midiWrapperMock.simulateInput(rwd25PcButton)
-    assert playerMock.position == 0.75
+    assert mockPlayer.position == 0.75
 
     midiWrapperMock.simulateInput(rwd5PcButton)
-    assert playerMock.position == 0.70
+    assert mockPlayer.position == 0.70
 
     midiWrapperMock.simulateInput(rwd1PcButton)
-    assert playerMock.position == 0.69
+    assert mockPlayer.position == 0.69
 
     midiWrapperMock.simulateInput(rwd25PcButton)
     midiWrapperMock.simulateInput(rwd25PcButton)
     midiWrapperMock.simulateInput(rwd25PcButton)
-    assert playerMock.position == 0.0
+    assert mockPlayer.position == 0.0
diff --git a/solo-tool-project/test/session_manager_unittest.py b/solo-tool-project/test/session_manager_unittest.py
index 8658032..cff3b35 100644
--- a/solo-tool-project/test/session_manager_unittest.py
+++ b/solo-tool-project/test/session_manager_unittest.py
@@ -1,24 +1,34 @@
 import pytest
 from json import loads
-import pathlib
-import shutil
+import os
 
 from solo_tool.session_manager import loadSession, saveSession
-from solo_tool.solo_tool import SoloTool
+from fixtures import songPool, soloTool, mockPlayer, testSongs
 
 @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 test_loadSession(prepared_tmp_path):
-    soloTool = loadSession(prepared_tmp_path / "test_session.json")
+def testSessionFile(tmp_path, testSongs):
+    contents = """[
+    {
+        "path" : "test.flac",
+        "key_points" : []
+    },
+    {
+        "path" : "test.mp3",
+        "key_points" : [0.1, 0.3]
+    }
+]"""
+
+    basePath = tmp_path / "sessions"
+    sessionFile = basePath / "test-session.json"
+
+    os.mkdir(basePath)
+    with open(sessionFile, "w") as f:
+        f.write(contents)
+
+    return sessionFile
+
+def test_loadSession(songPool, testSessionFile, mockPlayer):
+    soloTool = loadSession(testSessionFile, songPool, player=mockPlayer)
 
     assert soloTool.songs == ["test.flac", "test.mp3"]
 
@@ -28,31 +38,28 @@ def test_loadSession(prepared_tmp_path):
     soloTool.song = 1
     assert soloTool.keyPoints == [0.1, 0.3]
 
-def test_saveSession(prepared_tmp_path):
-    soloTool = SoloTool()
+def test_saveSession(soloTool, testSessionFile, tmp_path):
     soloTool.addSong("test.flac")
     soloTool.addSong("test.mp3")
     soloTool.song = 1
     soloTool.keyPoints = [0.1, 0.3]
 
-    testFile = prepared_tmp_path / "test_session_saved.json"
+    testFile = tmp_path / "test_session_saved.json"
     saveSession(soloTool, testFile)
 
     with open(testFile, "r") as f:
         savedSession = loads(f.read())
 
-    with open(prepared_tmp_path / "test_session.json", "r") as f:
+    with open(testSessionFile, "r") as f:
         testSession = loads(f.read())
 
     assert savedSession == testSession
 
-def test_loadAndSaveEmptySession(prepared_tmp_path):
-    emptyFile = prepared_tmp_path / "empty_session.json"
-
-    soloTool = SoloTool()
+def test_loadAndSaveEmptySession(songPool, soloTool, tmp_path):
+    emptyFile = tmp_path / "empty_session.json"
 
     saveSession(soloTool, emptyFile)
-    reloadedTool = loadSession(emptyFile)
+    reloadedTool = loadSession(emptyFile, songPool)
 
     assert reloadedTool.songs == []
     
diff --git a/solo-tool-project/test/solo_tool_integrationtest.py b/solo-tool-project/test/solo_tool_integrationtest.py
index f8ed2f1..5d8f14c 100644
--- a/solo-tool-project/test/solo_tool_integrationtest.py
+++ b/solo-tool-project/test/solo_tool_integrationtest.py
@@ -2,28 +2,7 @@ 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
+from fixtures import soloTool as uut, songPool, mockPlayer, testSongs
 
 def test_playerControls(uut, mockPlayer):
     assert not mockPlayer.playing
@@ -104,9 +83,8 @@ def test_sanitizePlaybackVolume(uut):
     uut.volume = 150.0
     assert uut.volume == 150.0
 
-def test_playingStateNotification(uut, mockPlayer):
-    song = "test.flac"
-    uut.addSong(song)
+def test_playingStateNotification(uut, mockPlayer, testSongs):
+    uut.addSong(testSongs[0])
 
     called = False
     receivedValue = None
@@ -134,10 +112,8 @@ def test_playingStateNotification(uut, mockPlayer):
     uut.pause()
     assert not called
 
-def test_playbackVolumeNotification(uut, mockPlayer):
-    song = "test.flac"
-    uut.addSong(song)
-    uut.song = 0
+def test_playbackVolumeNotification(uut, mockPlayer, testSongs):
+    uut.addSong(testSongs[0])
 
     called = False
     receivedValue = None
@@ -158,10 +134,8 @@ def test_playbackVolumeNotification(uut, mockPlayer):
     uut.volume = 0.3
     assert not called
 
-def test_playbackRateNotification(uut, mockPlayer):
-    song = "test.flac"
-    uut.addSong(song)
-    uut.song = 0
+def test_playbackRateNotification(uut, mockPlayer, testSongs):
+    uut.addSong(testSongs[0])
 
     called = False
     receivedValue = None
diff --git a/solo-tool-project/test/solo_tool_keypoints_integrationtest.py b/solo-tool-project/test/solo_tool_keypoints_integrationtest.py
index a0a8663..3db86f5 100644
--- a/solo-tool-project/test/solo_tool_keypoints_integrationtest.py
+++ b/solo-tool-project/test/solo_tool_keypoints_integrationtest.py
@@ -1,22 +1,6 @@
 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 testSongs():
-    return [
-        "test.flac",
-        "test.mp3"
-    ]
+from fixtures import soloTool as uut, songPool, mockPlayer, testSongs
 
 def test_keyPointAndSongSelection(uut, mockPlayer, testSongs):
     def checkJump(before, expectedAfter):
diff --git a/solo-tool-project/test/solo_tool_songs_integrationtest.py b/solo-tool-project/test/solo_tool_songs_integrationtest.py
index 092ea93..6030d19 100644
--- a/solo-tool-project/test/solo_tool_songs_integrationtest.py
+++ b/solo-tool-project/test/solo_tool_songs_integrationtest.py
@@ -1,22 +1,6 @@
 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(player=mockPlayer)
-
-@pytest.fixture
-def testSongs():
-    return [
-        "test.flac",
-        "test.mp3"
-    ]
+from fixtures import soloTool as uut, songPool, mockPlayer, testSongs
 
 def test_songSelectionFlow(uut, mockPlayer, testSongs):
     # Initially, song list is empty and no song is selected
@@ -33,7 +17,7 @@ def test_songSelectionFlow(uut, mockPlayer, testSongs):
     # Subsequently added songs are not selected automatically
     # Song list order is addition order
     for i, song in enumerate(testSongs[1:]):
-        uut.addSong(testSongs[1])
+        uut.addSong(song)
         assert uut.song == 0
         assert mockPlayer.currentSong == testSongs[0]
         assert uut.songs == testSongs[0:i + 2]
diff --git a/solo-tool-project/test/test.flac b/solo-tool-project/test/test.flac
deleted file mode 100644
index 9164735..0000000
--- a/solo-tool-project/test/test.flac
+++ /dev/null
diff --git a/solo-tool-project/test/test.mp3 b/solo-tool-project/test/test.mp3
deleted file mode 100644
index 3c353b7..0000000
--- a/solo-tool-project/test/test.mp3
+++ /dev/null
diff --git a/solo-tool-project/test/test_session.json b/solo-tool-project/test/test_session.json
deleted file mode 100644
index 49c2d42..0000000
--- a/solo-tool-project/test/test_session.json
+++ /dev/null
@@ -1,10 +0,0 @@
-[
-    {
-        "path" : "test.flac",
-        "key_points" : []
-    },
-    {
-        "path" : "test.mp3",
-        "key_points" : [0.1, 0.3]
-    }
-]