1 files changed, 41 insertions, 97 deletions
diff --git a/solo-tool-project/test/session_manager_unittest.py b/solo-tool-project/test/session_manager_unittest.py
index d89b82a..8658032 100644
--- a/solo-tool-project/test/session_manager_unittest.py
+++ b/solo-tool-project/test/session_manager_unittest.py
@@ -1,114 +1,58 @@
-from solo_tool.session_manager import loadSession, saveSession
-from json import loads, dumps
-
 import pytest
+from json import loads
+import pathlib
+import shutil
 
-testSession = [
-    {
-        "path" : "/path/to/another/song",
-        "ab_limits" : None
-    },
-    {
-        "path" : "/path/to/song",
-        "ab_limits" : [
-            [0.1, 0.2],
-            [0.3, 0.4]
-        ]
-    },
-    {
-        "path" : "/path/to/something",
-        "ab_limits" : [
-            [0.1, 0.2]
-        ]
-    }
-]
-
-class ABControllerMock:
-    def __init__(self):
-        self.limits = dict()
-
-    def storeLimits(self, aLimit, bLimit, song="current"):
-        if song not in self.limits: 
-            self.limits[song] = list()
-        self.limits[song].append([aLimit, bLimit])
-    
-    def getStoredLimits(self, song):
-        return self.limits.get(song)
-
-    def clear(self):
-        self.__init__()
-
-class MockFile:
-    def __init__(self, init=""):
-        self.contents = init
-
-    def open(self, *args):
-        pass
-
-    def write(self, s):
-        self.contents += s
-
-    def read(self):
-        return self.contents
-
-@pytest.fixture
-def playlistMock():
-    return []
+from solo_tool.session_manager import loadSession, saveSession
+from solo_tool.solo_tool import SoloTool
 
 @pytest.fixture
-def abControllerMock():
-    return ABControllerMock()
+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(playlistMock, abControllerMock):
-    sessionFile = MockFile(dumps(testSession))
-    loadSession(sessionFile, playlistMock, abControllerMock)
+def test_loadSession(prepared_tmp_path):
+    soloTool = loadSession(prepared_tmp_path / "test_session.json")
 
-    for i, entry in enumerate(testSession):
-        expectedSong = entry["path"]
-        expectedLimits = entry["ab_limits"]
-        loadedSong = playlistMock[i]
-        loadedLimits = abControllerMock.limits.get(expectedSong)
+    assert soloTool.songs == ["test.flac", "test.mp3"]
 
-        assert loadedSong == expectedSong
-        assert loadedLimits == expectedLimits
+    soloTool.song = 0
+    assert soloTool.keyPoints == []
 
-def test_saveSession(playlistMock, abControllerMock):
-    for i, entry in enumerate(testSession):
-        song = entry["path"]
-        playlistMock.append(song)
+    soloTool.song = 1
+    assert soloTool.keyPoints == [0.1, 0.3]
 
-        abLimits = entry["ab_limits"]
-        if abLimits is not None:
-            for l in abLimits:
-                abControllerMock.storeLimits(l[0], l[1], song)
+def test_saveSession(prepared_tmp_path):
+    soloTool = SoloTool()
+    soloTool.addSong("test.flac")
+    soloTool.addSong("test.mp3")
+    soloTool.song = 1
+    soloTool.keyPoints = [0.1, 0.3]
 
-    sessionFile = MockFile()
-    saveSession(sessionFile, playlistMock, abControllerMock)
+    testFile = prepared_tmp_path / "test_session_saved.json"
+    saveSession(soloTool, testFile)
 
-    savedSession = loads(sessionFile.read())
-    assert savedSession == testSession
+    with open(testFile, "r") as f:
+        savedSession = loads(f.read())
 
-def test_loadAndSaveEmptySession(playlistMock, abControllerMock):
-    sessionFile = MockFile()
+    with open(prepared_tmp_path / "test_session.json", "r") as f:
+        testSession = loads(f.read())
 
-    saveSession(sessionFile, playlistMock, abControllerMock)
-    assert loads(sessionFile.read()) == list()
+    assert savedSession == testSession
 
-    loadSession(sessionFile, playlistMock, abControllerMock)
+def test_loadAndSaveEmptySession(prepared_tmp_path):
+    emptyFile = prepared_tmp_path / "empty_session.json"
 
-    assert playlistMock == list()
-    for s in playlistMock:
-        assert abControllerMock.getStoredLimits(s) == None
+    soloTool = SoloTool()
 
-def test_loadSessionNotAdditive(playlistMock, abControllerMock):
-    sessionFile = MockFile(dumps(testSession))
-    loadSession(sessionFile, playlistMock, abControllerMock)
-    loadSession(sessionFile, playlistMock, abControllerMock)
+    saveSession(soloTool, emptyFile)
+    reloadedTool = loadSession(emptyFile)
 
-    songs = playlistMock
-    assert len(songs) == len(set(songs))
-    for s in songs:
-        abLimits = abControllerMock.getStoredLimits(s)
-        if abLimits is not None:
-            abLimitStr = [f"[{l[0]}, {l[1]}] " for l in abLimits]
-            assert len(abLimitStr) == len(set(abLimitStr))
+    assert reloadedTool.songs == []
+