aboutsummaryrefslogtreecommitdiffstats
path: root/solo-tool-project/test/session_manager_unittest.py
blob: e74bab4390e462bc260152eb2d5e4c54544e164b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
from solo_tool.session_manager import loadSession, saveSession
from json import loads, dumps

import pytest

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 songListMock():
    return []

@pytest.fixture
def abControllerMock():
    return ABControllerMock()

def test_loadSession(songListMock, abControllerMock):
    sessionFile = MockFile(dumps(testSession))
    loadSession(sessionFile, songListMock, abControllerMock)

    for i, entry in enumerate(testSession):
        expectedSong = entry["path"]
        expectedLimits = entry["ab_limits"]
        loadedSong = songListMock[i]
        loadedLimits = abControllerMock.limits.get(expectedSong)

        assert loadedSong == expectedSong
        assert loadedLimits == expectedLimits

def test_saveSession(songListMock, abControllerMock):
    for i, entry in enumerate(testSession):
        song = entry["path"]
        songListMock.append(song)

        abLimits = entry["ab_limits"]
        if abLimits is not None:
            for l in abLimits:
                abControllerMock.storeLimits(l[0], l[1], song)

    sessionFile = MockFile()
    saveSession(sessionFile, songListMock, abControllerMock)

    savedSession = loads(sessionFile.read())
    assert savedSession == testSession

def test_loadAndSaveEmptySession(songListMock, abControllerMock):
    sessionFile = MockFile()

    saveSession(sessionFile, songListMock, abControllerMock)
    assert loads(sessionFile.read()) == list()

    loadSession(sessionFile, songListMock, abControllerMock)

    assert songListMock == list()
    for s in songListMock:
        assert abControllerMock.getStoredLimits(s) == None

def test_loadSessionNotAdditive(songListMock, abControllerMock):
    sessionFile = MockFile(dumps(testSession))
    loadSession(sessionFile, songListMock, abControllerMock)
    loadSession(sessionFile, songListMock, abControllerMock)

    songs = songListMock
    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))