From 205d90b29fc9435fa01e5d1d07d207259fdd7e83 Mon Sep 17 00:00:00 2001
From: Ivan <ivan.ploxix@gmail.com>
Date: Tue, 10 Mar 2020 15:53:18 +0700
Subject: [PATCH 01/12] Update to Python3 and new Mopidy API

---
 mopidy_alarmclock/__init__.py      |  6 +++---
 mopidy_alarmclock/alarm_manager.py | 18 +++++++++---------
 mopidy_alarmclock/http.py          | 16 ++++++++--------
 3 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/mopidy_alarmclock/__init__.py b/mopidy_alarmclock/__init__.py
index bd00fd7..67acef8 100644
--- a/mopidy_alarmclock/__init__.py
+++ b/mopidy_alarmclock/__init__.py
@@ -1,9 +1,9 @@
-from __future__ import unicode_literals
+
 
 import os
-from http import MessageStore, factory_decorator
+from .http import MessageStore, factory_decorator
 
-from alarm_manager import AlarmManager
+from .alarm_manager import AlarmManager
 
 from mopidy import config, ext
 
diff --git a/mopidy_alarmclock/alarm_manager.py b/mopidy_alarmclock/alarm_manager.py
index d9d20ef..e46eca2 100644
--- a/mopidy_alarmclock/alarm_manager.py
+++ b/mopidy_alarmclock/alarm_manager.py
@@ -1,5 +1,5 @@
-from __future__ import division
-from __future__ import unicode_literals
+
+
 
 import datetime
 import logging
@@ -95,7 +95,7 @@ def play(self, fallback=False):
             if fallback:
                 raise Exception('Fallback')
             self.core.tracklist.add(self.get_playlist().tracks)
-            if self.core.tracklist.length.get() < 1:
+            if self.core.tracklist.get_length().get() < 1:
                 raise Exception('Tracklist empty')
         except Exception as e:
             self.logger.info("AlarmClock using backup alarm, reason: %s", e)
@@ -109,8 +109,8 @@ def play(self, fallback=False):
         if self.core.tracklist.random:
             self.core.playback.next()
 
-        self.core.playback.mute = False
-        self.core.playback.volume = 0
+        self.core.mixer.set_mute(False)
+        self.core.mixer.set_volume(0).get()
 
         self.core.playback.play()
 
@@ -121,7 +121,7 @@ def play(self, fallback=False):
             try:
                 starttime = monotonic.monotonic()
                 time.sleep(0.5)
-                while self.core.playback.state.get() != PlaybackState.PLAYING or self.core.playback.time_position.get() < 100:  # in some cases this check will cause a notable delay
+                while self.core.playback.get_state().get() != PlaybackState.PLAYING or self.core.playback.get_time_position().get() < 100:  # in some cases this check will cause a notable delay
                     self.logger.info("AlarmClock has been waiting for %.2f seconds (waited inside AlarmClock %.2f sec)", monotonic.monotonic() - starttime, waited)
                     if waited > 30 or (waited > 0.5 and monotonic.monotonic() - starttime > 30):  # ensure EITHER delay is more than 30 seconds OR at least 2 times above line has been executed
                         raise Exception("Timeout")
@@ -151,15 +151,15 @@ def adjust_volume(self, target_volume, increase_duration, step_no):
         number_of_steps = min(target_volume, increase_duration)
         current_volume = None
         try:
-            current_volume = self.core.playback.volume.get()
+            current_volume = self.core.mixer.get_volume().get()
         except Exception:
             pass
         if step_no == 0 or not isinstance(current_volume, int) or current_volume == int(round(target_volume * (step_no) / (number_of_steps + 1))):
             if step_no >= number_of_steps:  # this design should prevent floating-point edge-case bugs (in case such bugs could be possible here)
                 self.logger.info("AlarmClock increasing volume to target volume %d", target_volume)
-                self.core.playback.volume = target_volume
+                self.core.mixer.set_volume(target_volume).get()
             else:
                 self.logger.info("AlarmClock increasing volume to %d", int(round(target_volume * (step_no + 1) / (number_of_steps + 1))))
-                self.core.playback.volume = int(round(target_volume * (step_no + 1) / (number_of_steps + 1)))
+                self.core.mixer.set_volume(int(round(target_volume * (step_no + 1) / (number_of_steps + 1)))).get()
                 t = Timer(increase_duration / number_of_steps, self.adjust_volume, [target_volume, increase_duration, step_no + 1])
                 t.start()
diff --git a/mopidy_alarmclock/http.py b/mopidy_alarmclock/http.py
index bae02b0..b2cf072 100644
--- a/mopidy_alarmclock/http.py
+++ b/mopidy_alarmclock/http.py
@@ -1,4 +1,4 @@
-from __future__ import unicode_literals
+
 
 import datetime
 import os
@@ -12,9 +12,9 @@
 template_loader = tornado.template.Loader(template_directory)
 
 MESSAGES = {
-    'ok': (u'Alarm has been properly set.', 'success'),
-    'format': (u'The date\'s format you specified is incorrect.', 'danger'),
-    'cancel': (u'Alarm has been canceled.', 'success'),
+    'ok': ('Alarm has been properly set.', 'success'),
+    'format': ('The date\'s format you specified is incorrect.', 'danger'),
+    'cancel': ('Alarm has been canceled.', 'success'),
 }
 
 
@@ -36,9 +36,9 @@ def get(self):
         if self.msg_store.msg_code and self.msg_store.msg_code in MESSAGES:
             message = MESSAGES[self.msg_store.msg_code]
             self.msg_store.msg_code = None
-
-        playlists = self.core.playlists.playlists.get()
-
+        
+        playlists = self.core.playlists.as_list().get()
+        
         self.write(template_loader.load('index.html').generate(
             playlists=playlists,
             alarm_manager=self.alarm_manager,
@@ -65,7 +65,7 @@ def post(self):
             volume_increase_seconds = 30
 
         if matched:
-            time_comp = map(lambda x: int(x), matched.groups())
+            time_comp = [int(x) for x in matched.groups()]
             time = datetime.time(hour=time_comp[0], minute=time_comp[1])
 
             dt = datetime.datetime.combine(datetime.datetime.now(), time)

From 3425a8669a6b0066be0c5064e62712a787b50dc3 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Tue, 17 Mar 2020 00:58:50 +0200
Subject: [PATCH 02/12] Fixed fallback and play settings

And removed unnecessary .get() calls
---
 mopidy_alarmclock/alarm_manager.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/mopidy_alarmclock/alarm_manager.py b/mopidy_alarmclock/alarm_manager.py
index e46eca2..574c941 100644
--- a/mopidy_alarmclock/alarm_manager.py
+++ b/mopidy_alarmclock/alarm_manager.py
@@ -99,18 +99,18 @@ def play(self, fallback=False):
                 raise Exception('Tracklist empty')
         except Exception as e:
             self.logger.info("AlarmClock using backup alarm, reason: %s", e)
-            self.core.tracklist.add(None, 0, 'file://' + os.path.join(os.path.dirname(__file__), 'backup-alarm.mp3'))
+            self.core.tracklist.add(None, 0, ['file://' + os.path.join(os.path.dirname(__file__), 'backup-alarm.mp3')])
 
-        self.core.tracklist.consume = False
-        self.core.tracklist.single = False
-        self.core.tracklist.repeat = True
+        self.core.tracklist.set_consume(False)
+        self.core.tracklist.set_single(False)
+        self.core.tracklist.set_repeat(True)
 
-        self.core.tracklist.random = self.random_mode
-        if self.core.tracklist.random:
+        self.core.tracklist.set_random(self.random_mode)
+        if self.random_mode:
             self.core.playback.next()
 
         self.core.mixer.set_mute(False)
-        self.core.mixer.set_volume(0).get()
+        self.core.mixer.set_volume(0)
 
         self.core.playback.play()
 
@@ -157,9 +157,9 @@ def adjust_volume(self, target_volume, increase_duration, step_no):
         if step_no == 0 or not isinstance(current_volume, int) or current_volume == int(round(target_volume * (step_no) / (number_of_steps + 1))):
             if step_no >= number_of_steps:  # this design should prevent floating-point edge-case bugs (in case such bugs could be possible here)
                 self.logger.info("AlarmClock increasing volume to target volume %d", target_volume)
-                self.core.mixer.set_volume(target_volume).get()
+                self.core.mixer.set_volume(target_volume)
             else:
                 self.logger.info("AlarmClock increasing volume to %d", int(round(target_volume * (step_no + 1) / (number_of_steps + 1))))
-                self.core.mixer.set_volume(int(round(target_volume * (step_no + 1) / (number_of_steps + 1)))).get()
+                self.core.mixer.set_volume(int(round(target_volume * (step_no + 1) / (number_of_steps + 1))))
                 t = Timer(increase_duration / number_of_steps, self.adjust_volume, [target_volume, increase_duration, step_no + 1])
                 t.start()

From d8ef75d91050a53079a6f6977605eef305d3079f Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Tue, 17 Mar 2020 01:03:51 +0200
Subject: [PATCH 03/12] Improve formatting

---
 mopidy_alarmclock/__init__.py      | 7 ++-----
 mopidy_alarmclock/alarm_manager.py | 3 ---
 mopidy_alarmclock/http.py          | 6 ++----
 3 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/mopidy_alarmclock/__init__.py b/mopidy_alarmclock/__init__.py
index 67acef8..9d88c21 100644
--- a/mopidy_alarmclock/__init__.py
+++ b/mopidy_alarmclock/__init__.py
@@ -1,11 +1,8 @@
-
-
 import os
-from .http import MessageStore, factory_decorator
+from mopidy import config, ext
 
 from .alarm_manager import AlarmManager
-
-from mopidy import config, ext
+from .http import MessageStore, factory_decorator
 
 
 __version__ = '0.1.7'
diff --git a/mopidy_alarmclock/alarm_manager.py b/mopidy_alarmclock/alarm_manager.py
index 574c941..1792d8e 100644
--- a/mopidy_alarmclock/alarm_manager.py
+++ b/mopidy_alarmclock/alarm_manager.py
@@ -1,6 +1,3 @@
-
-
-
 import datetime
 import logging
 import os
diff --git a/mopidy_alarmclock/http.py b/mopidy_alarmclock/http.py
index b2cf072..be05bd5 100644
--- a/mopidy_alarmclock/http.py
+++ b/mopidy_alarmclock/http.py
@@ -1,5 +1,3 @@
-
-
 import datetime
 import os
 import re
@@ -36,9 +34,9 @@ def get(self):
         if self.msg_store.msg_code and self.msg_store.msg_code in MESSAGES:
             message = MESSAGES[self.msg_store.msg_code]
             self.msg_store.msg_code = None
-        
+
         playlists = self.core.playlists.as_list().get()
-        
+
         self.write(template_loader.load('index.html').generate(
             playlists=playlists,
             alarm_manager=self.alarm_manager,

From ae99f3b3e2dae482292492ae1ddab512549f2e7b Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Tue, 17 Mar 2020 08:57:01 +0200
Subject: [PATCH 04/12] Improve formatting (attempt 2)

---
 mopidy_alarmclock/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mopidy_alarmclock/__init__.py b/mopidy_alarmclock/__init__.py
index 9d88c21..b2b16c5 100644
--- a/mopidy_alarmclock/__init__.py
+++ b/mopidy_alarmclock/__init__.py
@@ -1,4 +1,5 @@
 import os
+
 from mopidy import config, ext
 
 from .alarm_manager import AlarmManager

From 7ec424c9f812f90b7d7eb5c7f52a6a87bbcaef32 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Tue, 17 Mar 2020 20:27:43 +0200
Subject: [PATCH 05/12] Update requirements

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index a482414..a66be49 100644
--- a/setup.py
+++ b/setup.py
@@ -27,7 +27,7 @@ def get_version(filename):
     include_package_data=True,
     install_requires=[
         'setuptools',
-        'Mopidy >= 0.19',
+        'Mopidy >= 3.0',
         'Pykka >= 1.1',
         'monotonic >= 1.4',
     ],

From 9e30922c64c7f31d44ed3abb726960ad977454c0 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Tue, 17 Mar 2020 20:34:04 +0200
Subject: [PATCH 06/12] Update setup and CI config

---
 .travis.yml | 8 ++++----
 setup.py    | 2 --
 tox.ini     | 6 +++---
 3 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 397fc0a..7d5d2dd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,15 +2,15 @@ language: python
 sudo: true
 
 python:
-  - "2.7_with_system_site_packages"
+  - "3.7_with_system_site_packages"
 
 env:
-  - TOX_ENV=py27
+  - TOX_ENV=py37
   - TOX_ENV=flake8
 
 before_install:
   - sudo apt-get update
-  - sudo apt-get install -y python-gi python-gst-1.0 gir1.2-gstreamer-1.0 gir1.2-gst-plugins-base-1.0 gstreamer1.0-plugins-good gstreamer1.0-plugins-ugly gstreamer1.0-tools
+  - sudo apt-get install -y python-gi
 
 install:
   - "pip install tox"
@@ -19,4 +19,4 @@ script:
   - "tox -e $TOX_ENV"
 
 after_success:
-  - "if [ $TOX_ENV == 'py27' ]; then pip install coveralls requests==2.2.1; coveralls; fi"
\ No newline at end of file
+  - "if [ $TOX_ENV == 'py37' ]; then pip install coveralls requests; coveralls; fi"
\ No newline at end of file
diff --git a/setup.py b/setup.py
index a66be49..74b105d 100644
--- a/setup.py
+++ b/setup.py
@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 import re
 
 from setuptools import find_packages, setup
diff --git a/tox.ini b/tox.ini
index 1324e35..ec25a9c 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = py27, flake8
+envlist = py37, flake8
 
 [testenv]
 sitepackages = true
@@ -9,14 +9,14 @@ deps =
     nose
     freezegun
     mopidy
-    tornado<5.0
+    tornado
 commands = nosetests -v --with-xunit --xunit-file=xunit-{envname}.xml --with-coverage --cover-package=mopidy_alarmclock
 
 [testenv:flake8]
 deps =
     flake8
     flake8-import-order
-    tornado<5.0
+    tornado
 commands = flake8
 
 [flake8]

From e8c136970d96e56e88fb6e8462df9306197e2f40 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Tue, 17 Mar 2020 20:40:20 +0200
Subject: [PATCH 07/12] Fixing CI builds

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 7d5d2dd..c72a42b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,7 +2,7 @@ language: python
 sudo: true
 
 python:
-  - "3.7_with_system_site_packages"
+  - "3.7"
 
 env:
   - TOX_ENV=py37

From b8a80bd242c58cd74054e1dd1e73f3d4d3466b06 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Tue, 17 Mar 2020 20:50:02 +0200
Subject: [PATCH 08/12] flake8: remove leading zeros

octal prefix in Python 2.7 (that didn't change anything in this case)
---
 tests/test_http.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/test_http.py b/tests/test_http.py
index 69c760b..310cbb7 100644
--- a/tests/test_http.py
+++ b/tests/test_http.py
@@ -33,7 +33,7 @@ def test_SetAlarmRequestHandler(self):
 
         handler.post()
 
-        alarm_manager.set_alarm.assert_called_once_with(datetime.datetime(2015, 05, 03, 8, 0), 'Playlist URI', True, 81, 23)
+        alarm_manager.set_alarm.assert_called_once_with(datetime.datetime(2015, 5, 3, 8, 0), 'Playlist URI', True, 81, 23)
         self.assertEqual(msg_store.msg_code, 'ok')
         handler.redirect.assert_called_once_with('/alarmclock/')
 
@@ -49,7 +49,7 @@ def test_SetAlarmRequestHandler(self):
 
         # WARNING! Default configuration must be also updated in README.rst and ext.conf
         # WARNING! Internal defaults of volume and volume increase seconds are in SetAlarmRequestHandler of http.py
-        alarm_manager.set_alarm.assert_called_once_with(datetime.datetime(2015, 05, 04, 5, 7), 'Playlist URI', False, 100, 30)
+        alarm_manager.set_alarm.assert_called_once_with(datetime.datetime(2015, 5, 4, 5, 7), 'Playlist URI', False, 100, 30)
         self.assertEqual(msg_store.msg_code, 'ok')
         handler.redirect.assert_called_once_with('/alarmclock/')
 
@@ -66,7 +66,7 @@ def test_SetAlarmRequestHandler(self):
         # WARNING! Default configuration (AND RANGES) must be also updated in README.rst and ext.conf
         # WARNING! Internal defaults of volume and volume increase seconds are in SetAlarmRequestHandler of http.py
         # WARNING! Ranges of volume and volume increase seconds are in SetAlarmRequestHandler of http.py AND HTML form of index.html
-        alarm_manager.set_alarm.assert_called_once_with(datetime.datetime(2015, 05, 03, 23, 59), 'Playlist URI', True, 100, 30)
+        alarm_manager.set_alarm.assert_called_once_with(datetime.datetime(2015, 5, 3, 23, 59), 'Playlist URI', True, 100, 30)
         self.assertEqual(msg_store.msg_code, 'ok')
         handler.redirect.assert_called_once_with('/alarmclock/')
 
@@ -83,7 +83,7 @@ def test_SetAlarmRequestHandler(self):
         # WARNING! Default configuration (AND RANGES) must be also updated in README.rst and ext.conf
         # WARNING! Internal defaults of volume and volume increase seconds are in SetAlarmRequestHandler of http.py
         # WARNING! Ranges of volume and volume increase seconds are in SetAlarmRequestHandler of http.py AND HTML form of index.html
-        alarm_manager.set_alarm.assert_called_once_with(datetime.datetime(2015, 05, 04, 0, 0), 'Playlist URI', True, 100, 30)
+        alarm_manager.set_alarm.assert_called_once_with(datetime.datetime(2015, 5, 4, 0, 0), 'Playlist URI', True, 100, 30)
         self.assertEqual(msg_store.msg_code, 'ok')
         handler.redirect.assert_called_once_with('/alarmclock/')
 

From f18014547b0efc65b36c6e6143a5fd900f509938 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Wed, 18 Mar 2020 23:28:32 +0200
Subject: [PATCH 09/12] tests: mock gi package

---
 .travis.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index c72a42b..e2ead9f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,8 +9,9 @@ env:
   - TOX_ENV=flake8
 
 before_install:
-  - sudo apt-get update
-  - sudo apt-get install -y python-gi
+  - export PYUSRSITEDIR=$(python -m site --user-site)
+  - mkdir -p $PYUSRSITEDIR
+  - "echo \"import sys; import mock; sys.modules['gi'] = mock.Mock(); sys.modules['gi.repository'] = mock.Mock(); sys.modules['gi.repository'].Gst.version.side_effect = lambda: (1, 14, 0)\" > ${PYUSRSITEDIR}/usercustomize.py"
 
 install:
   - "pip install tox"

From 954ede5dde8adb6ac737977e6c865356b3bbaa33 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Thu, 19 Mar 2020 01:15:34 +0200
Subject: [PATCH 10/12] tests: some fixes

---
 tests/test_alarm_manager.py | 310 +++++++++++++++++++++---------------
 1 file changed, 186 insertions(+), 124 deletions(-)

diff --git a/tests/test_alarm_manager.py b/tests/test_alarm_manager.py
index 7ee6bc4..c65035c 100644
--- a/tests/test_alarm_manager.py
+++ b/tests/test_alarm_manager.py
@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 import datetime
 import os
 import threading
@@ -100,10 +98,10 @@ def test02_set_alarm__threading(self):
     def test02_set_alarm__empty_playlist(self):
         core = mock.Mock()
         playlist = 'Playlist URI'
-        core.playback.state.get.side_effect = lambda: PlaybackState.PLAYING
-        core.playback.time_position.get.side_effect = lambda: 234
+        core.playback.get_state().get.side_effect = lambda: PlaybackState.PLAYING
+        core.playback.get_time_position().get.side_effect = lambda: 234
         core.playlists.lookup('Playlist URI').get().tracks = 'Tracks 811, 821, 823, 827, 829, 839'
-        core.tracklist.length.get.side_effect = lambda: 4
+        core.tracklist.get_length().get.side_effect = lambda: 4
         self.assertEqual(core.playlists.lookup.call_count, 1)  # First call when setting up the Mock
 
         am = AlarmManager()
@@ -120,7 +118,7 @@ def test02_set_alarm__empty_playlist(self):
         # Cleanup and re-setup
         core.tracklist.add.reset_mock()
         core.playback.play.reset_mock()
-        core.tracklist.length.get.side_effect = lambda: 0  # Simulate empty play queue
+        core.tracklist.get_length().get.side_effect = lambda: 0  # Simulate empty play queue
 
         # Set alarm to PAST
         am.set_alarm(datetime.datetime(2000, 4, 28, 7, 59, 15, 324341), playlist, False, 83, 0)
@@ -129,16 +127,16 @@ def test02_set_alarm__empty_playlist(self):
         self.assertEqual(core.playlists.lookup.call_count, 3)
         self.assertEqual(core.tracklist.add.call_count, 2)
         core.tracklist.add.assert_any_call('Tracks 811, 821, 823, 827, 829, 839')
-        core.tracklist.add.assert_called_with(None, 0, 'file://' + os.path.dirname(os.path.dirname(__file__)) + '/mopidy_alarmclock/backup-alarm.mp3')
+        core.tracklist.add.assert_called_with(None, 0, ['file://' + os.path.dirname(os.path.dirname(__file__)) + '/mopidy_alarmclock/backup-alarm.mp3'])
         core.playback.play.assert_called_once_with()
 
     def test02_set_alarm__broken_playback(self):
         core = mock.Mock()
         playlist = 'Playlist URI'
-        core.playback.state.get.side_effect = lambda: PlaybackState.PLAYING
-        core.playback.time_position.get.side_effect = lambda: 234
+        core.playback.get_state().get.side_effect = lambda: PlaybackState.PLAYING
+        core.playback.get_time_position().get.side_effect = lambda: 234
         core.playlists.lookup('Playlist URI').get().tracks = 'Tracks 811, 821, 823, 827, 829, 839'
-        core.tracklist.length.get.side_effect = lambda: 4
+        core.tracklist.get_length().get.side_effect = lambda: 4
         self.assertEqual(core.playlists.lookup.call_count, 1)  # First call when setting up the Mock
 
         am = AlarmManager()
@@ -155,10 +153,10 @@ def test02_set_alarm__broken_playback(self):
         # Cleanup and re-setup (part 2 starts here)
         core.tracklist.add.reset_mock()
         core.playback.play.reset_mock()
-        core.playback.state.get.reset_mock()
-        core.playback.time_position.get.reset_mock()
-        core.playback.state.get.side_effect = lambda: PlaybackState.PLAYING
-        core.playback.time_position.get.side_effect = lambda: 0  # simulate broken playback (stuck at 0 milliseconds)
+        core.playback.get_state().get.reset_mock()
+        core.playback.get_time_position().get.reset_mock()
+        core.playback.get_state().get.side_effect = lambda: PlaybackState.PLAYING
+        core.playback.get_time_position().get.side_effect = lambda: 0  # simulate broken playback (stuck at 0 milliseconds)
 
         # Set alarm to PAST
         am.set_alarm(datetime.datetime(2000, 4, 28, 7, 59, 15, 324341), playlist, False, 83, 0)
@@ -167,22 +165,22 @@ def test02_set_alarm__broken_playback(self):
         self.assertEqual(core.playlists.lookup.call_count, 3)
         self.assertEqual(core.tracklist.add.call_count, 2)
         core.tracklist.add.assert_any_call('Tracks 811, 821, 823, 827, 829, 839')
-        core.tracklist.add.assert_called_with(None, 0, 'file://' + os.path.dirname(os.path.dirname(__file__)) + '/mopidy_alarmclock/backup-alarm.mp3')
+        core.tracklist.add.assert_called_with(None, 0, ['file://' + os.path.dirname(os.path.dirname(__file__)) + '/mopidy_alarmclock/backup-alarm.mp3'])
         self.assertEqual(core.playback.play.call_count, 2)
 
         # Ensure playback was checked around 31 times (tolerate 1 sec possible slowness of build env)
-        self.assertGreaterEqual(core.playback.state.get.call_count, 30)
-        self.assertLess(core.playback.state.get.call_count, 32)
-        self.assertGreaterEqual(core.playback.time_position.get.call_count, 30)
-        self.assertLess(core.playback.time_position.get.call_count, 32)
+        self.assertGreaterEqual(core.playback.get_state().get.call_count, 30)
+        self.assertLess(core.playback.get_state().get.call_count, 32)
+        self.assertGreaterEqual(core.playback.get_time_position().get.call_count, 30)
+        self.assertLess(core.playback.get_time_position().get.call_count, 32)
 
         # Cleanup and re-setup (part 3 starts here)
         core.tracklist.add.reset_mock()
         core.playback.play.reset_mock()
-        core.playback.state.get.reset_mock()
-        core.playback.time_position.get.reset_mock()
-        core.playback.state.get.side_effect = lambda: time.sleep(31)  # simulate broken playback (return invalid state after 31 second delay)
-        core.playback.time_position.get.side_effect = lambda: 234
+        core.playback.get_state().get.reset_mock()
+        core.playback.get_time_position().get.reset_mock()
+        core.playback.get_state().get.side_effect = lambda: time.sleep(31)  # simulate broken playback (return invalid state after 31 second delay)
+        core.playback.get_time_position().get.side_effect = lambda: 234
 
         # Set alarm to PAST
         am.set_alarm(datetime.datetime(2000, 4, 28, 7, 59, 15, 324341), playlist, False, 83, 0)
@@ -191,12 +189,12 @@ def test02_set_alarm__broken_playback(self):
         self.assertEqual(core.playlists.lookup.call_count, 4)
         self.assertEqual(core.tracklist.add.call_count, 2)
         core.tracklist.add.assert_any_call('Tracks 811, 821, 823, 827, 829, 839')
-        core.tracklist.add.assert_called_with(None, 0, 'file://' + os.path.dirname(os.path.dirname(__file__)) + '/mopidy_alarmclock/backup-alarm.mp3')
+        core.tracklist.add.assert_called_with(None, 0, ['file://' + os.path.dirname(os.path.dirname(__file__)) + '/mopidy_alarmclock/backup-alarm.mp3'])
         self.assertEqual(core.playback.play.call_count, 2)
 
         # Ensure playback was checked exactly 2 times (due to delay during checking)
-        self.assertEqual(core.playback.state.get.call_count, 2)
-        self.assertEqual(core.playback.time_position.get.call_count, 0)  # actually this does not get called (because it is 2 operand in or)
+        self.assertEqual(core.playback.get_state().get.call_count, 2)
+        self.assertEqual(core.playback.get_time_position().get.call_count, 0)  # actually this does not get called (because it is 2 operand in or)
 
     def test02_get_ring_time(self):
         playlist = 'Playlist URI'
@@ -205,15 +203,15 @@ def test02_get_ring_time(self):
 
         am.set_alarm(datetime.datetime(2055, 4, 28, 7, 59, 15, 324341), playlist, False, 41, 83)
 
-        self.assertEqual(am.get_ring_time(), b'07:59')
+        self.assertEqual(am.get_ring_time(), '07:59')
 
         am.cancel()
 
     def test03_cancel(self):
         core = mock.Mock()
         playlist = 'Playlist URI'
-        core.playback.state.get.side_effect = lambda: PlaybackState.PLAYING
-        core.playback.time_position.get.side_effect = lambda: 234
+        core.playback.get_state().get.side_effect = lambda: PlaybackState.PLAYING
+        core.playback.get_time_position().get.side_effect = lambda: 234
         threadcount = threading.active_count()
 
         am = AlarmManager()
@@ -248,14 +246,14 @@ def test03_cancel(self):
 
         # Ensure that alarm has not started (incomplete test)
         self.assertEqual(core.playback.play.call_count, 0)
-        self.assertIsInstance(core.playback.volume, mock.Mock)
+        self.assertEqual(core.mixer.set_volume.call_count, 0)
 
         # Set alarm to PAST
         am.set_alarm(datetime.datetime(2000, 4, 28, 7, 59, 15, 324341), playlist, False, 83, 0)
 
         # Ensure that alarm went off (incomplete test)
         core.playback.play.assert_called_once_with()
-        self.assertEqual(core.playback.volume, 83)
+        core.mixer.set_volume.assert_called_with(83)
 
         self.assertFalse(am.is_set())
         self.assertEqual(threading.active_count(), threadcount)
@@ -276,14 +274,16 @@ def test03_adjust_volume__100_1(self):
 
         am.adjust_volume(100, 1, 0)
 
-        self.assertEqual(core.playback.volume, 50)
+        core.mixer.set_volume.assert_called_once_with(50)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1.2)  # First step has additional 0.2 seconds to prevent race conditions
-        self.assertEqual(core.playback.volume, 100)
+        self.assertEqual(core.mixer.set_volume.call_count, 2)
+        core.mixer.set_volume.assert_called_with(100)
         self.assertEqual(threading.active_count(), threadcount)
 
         time.sleep(5)  # More than 3x increase step time
-        self.assertEqual(core.playback.volume, 100)
+        self.assertEqual(core.mixer.set_volume.call_count, 2)
+        core.mixer.set_volume.assert_called_with(100)
         self.assertEqual(threading.active_count(), threadcount)
 
     def test03_adjust_volume__100_0(self):
@@ -297,11 +297,11 @@ def test03_adjust_volume__100_0(self):
 
         am.adjust_volume(100, 0, 0)
 
-        self.assertEqual(core.playback.volume, 100)
+        core.mixer.set_volume.assert_called_once_with(100)
         self.assertEqual(threading.active_count(), threadcount)
 
         time.sleep(5)  # More than 3x increase step time
-        self.assertEqual(core.playback.volume, 100)
+        core.mixer.set_volume.assert_called_once_with(100)
         self.assertEqual(threading.active_count(), threadcount)
 
     def test03_adjust_volume__3_17(self):
@@ -315,20 +315,24 @@ def test03_adjust_volume__3_17(self):
 
         am.adjust_volume(3, 17, 0)
 
-        self.assertEqual(core.playback.volume, 1)
+        core.mixer.set_volume.assert_called_once_with(1)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(5.87)  # First step has additional 0.2 seconds to prevent race conditions
-        self.assertEqual(core.playback.volume, 2)
+        self.assertEqual(core.mixer.set_volume.call_count, 2)
+        core.mixer.set_volume.assert_called_with(2)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(5.67)
-        self.assertEqual(core.playback.volume, 2)
+        self.assertEqual(core.mixer.set_volume.call_count, 3)
+        core.mixer.set_volume.assert_called_with(2)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(5.67)
-        self.assertEqual(core.playback.volume, 3)
+        self.assertEqual(core.mixer.set_volume.call_count, 4)
+        core.mixer.set_volume.assert_called_with(3)
         self.assertEqual(threading.active_count(), threadcount)
 
         time.sleep(20)  # More than 3x increase step time
-        self.assertEqual(core.playback.volume, 3)
+        self.assertEqual(core.mixer.set_volume.call_count, 4)
+        core.mixer.set_volume.assert_called_with(3)
         self.assertEqual(threading.active_count(), threadcount)
 
     def test03_adjust_volume__80_10(self):
@@ -337,41 +341,50 @@ def test03_adjust_volume__80_10(self):
 
         am = AlarmManager()
         am.get_core(core)
-        core.playback.volume = mock.Mock()
-        core.playback.volume.get.side_effect = lambda: 14  # Set volume before test to 14
 
         self.assertEqual(threading.active_count(), threadcount)
 
         am.adjust_volume(80, 10, 0)
 
-        self.assertEqual(core.playback.volume, 7)
+        core.mixer.set_volume.assert_called_once_with(7)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1.2)  # First step has additional 0.2 seconds to prevent race conditions
-        self.assertEqual(core.playback.volume, 15)
+        self.assertEqual(core.mixer.set_volume.call_count, 2)
+        core.mixer.set_volume.assert_called_with(15)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 22)
+        self.assertEqual(core.mixer.set_volume.call_count, 3)
+        core.mixer.set_volume.assert_called_with(22)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 29)
+        self.assertEqual(core.mixer.set_volume.call_count, 4)
+        core.mixer.set_volume.assert_called_with(29)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 36)
+        self.assertEqual(core.mixer.set_volume.call_count, 5)
+        core.mixer.set_volume.assert_called_with(36)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 44)
+        self.assertEqual(core.mixer.set_volume.call_count, 6)
+        core.mixer.set_volume.assert_called_with(44)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 51)
+        self.assertEqual(core.mixer.set_volume.call_count, 7)
+        core.mixer.set_volume.assert_called_with(51)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 58)
+        self.assertEqual(core.mixer.set_volume.call_count, 8)
+        core.mixer.set_volume.assert_called_with(58)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 65)
+        self.assertEqual(core.mixer.set_volume.call_count, 9)
+        core.mixer.set_volume.assert_called_with(65)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 73)
+        self.assertEqual(core.mixer.set_volume.call_count, 10)
+        core.mixer.set_volume.assert_called_with(73)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 80)
+        self.assertEqual(core.mixer.set_volume.call_count, 11)
+        core.mixer.set_volume.assert_called_with(80)
         self.assertEqual(threading.active_count(), threadcount)
 
         time.sleep(5)  # More than 3x increase step time
-        self.assertEqual(core.playback.volume, 80)
+        self.assertEqual(core.mixer.set_volume.call_count, 11)
+        core.mixer.set_volume.assert_called_with(80)
         self.assertEqual(threading.active_count(), threadcount)
 
     def test03_adjust_volume__100_30(self):
@@ -385,74 +398,105 @@ def test03_adjust_volume__100_30(self):
 
         am.adjust_volume(100, 30, 0)
 
-        self.assertEqual(core.playback.volume, 3)
+        core.mixer.set_volume.assert_called_once_with(3)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1.2)  # First step has additional 0.2 seconds to prevent race conditions
-        self.assertEqual(core.playback.volume, 6)
+        self.assertEqual(core.mixer.set_volume.call_count, 2)
+        core.mixer.set_volume.assert_called_with(6)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 10)
+        self.assertEqual(core.mixer.set_volume.call_count, 3)
+        core.mixer.set_volume.assert_called_with(10)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 13)
+        self.assertEqual(core.mixer.set_volume.call_count, 4)
+        core.mixer.set_volume.assert_called_with(13)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 16)
+        self.assertEqual(core.mixer.set_volume.call_count, 5)
+        core.mixer.set_volume.assert_called_with(16)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 19)
+        self.assertEqual(core.mixer.set_volume.call_count, 6)
+        core.mixer.set_volume.assert_called_with(19)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 23)
+        self.assertEqual(core.mixer.set_volume.call_count, 7)
+        core.mixer.set_volume.assert_called_with(23)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 26)
+        self.assertEqual(core.mixer.set_volume.call_count, 8)
+        core.mixer.set_volume.assert_called_with(26)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 29)
+        self.assertEqual(core.mixer.set_volume.call_count, 9)
+        core.mixer.set_volume.assert_called_with(29)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 32)
+        self.assertEqual(core.mixer.set_volume.call_count, 10)
+        core.mixer.set_volume.assert_called_with(32)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 35)
+        self.assertEqual(core.mixer.set_volume.call_count, 11)
+        core.mixer.set_volume.assert_called_with(35)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 39)
+        self.assertEqual(core.mixer.set_volume.call_count, 12)
+        core.mixer.set_volume.assert_called_with(39)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 42)
+        self.assertEqual(core.mixer.set_volume.call_count, 13)
+        core.mixer.set_volume.assert_called_with(42)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 45)
+        self.assertEqual(core.mixer.set_volume.call_count, 14)
+        core.mixer.set_volume.assert_called_with(45)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 48)
+        self.assertEqual(core.mixer.set_volume.call_count, 15)
+        core.mixer.set_volume.assert_called_with(48)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 52)
+        self.assertEqual(core.mixer.set_volume.call_count, 16)
+        core.mixer.set_volume.assert_called_with(52)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 55)
+        self.assertEqual(core.mixer.set_volume.call_count, 17)
+        core.mixer.set_volume.assert_called_with(55)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 58)
+        self.assertEqual(core.mixer.set_volume.call_count, 18)
+        core.mixer.set_volume.assert_called_with(58)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 61)
+        self.assertEqual(core.mixer.set_volume.call_count, 19)
+        core.mixer.set_volume.assert_called_with(61)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 65)
+        self.assertEqual(core.mixer.set_volume.call_count, 20)
+        core.mixer.set_volume.assert_called_with(65)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 68)
+        self.assertEqual(core.mixer.set_volume.call_count, 21)
+        core.mixer.set_volume.assert_called_with(68)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 71)
+        self.assertEqual(core.mixer.set_volume.call_count, 22)
+        core.mixer.set_volume.assert_called_with(71)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 74)
+        self.assertEqual(core.mixer.set_volume.call_count, 23)
+        core.mixer.set_volume.assert_called_with(74)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 77)
+        self.assertEqual(core.mixer.set_volume.call_count, 24)
+        core.mixer.set_volume.assert_called_with(77)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 81)
+        self.assertEqual(core.mixer.set_volume.call_count, 25)
+        core.mixer.set_volume.assert_called_with(81)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 84)
+        self.assertEqual(core.mixer.set_volume.call_count, 26)
+        core.mixer.set_volume.assert_called_with(84)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 87)
+        self.assertEqual(core.mixer.set_volume.call_count, 27)
+        core.mixer.set_volume.assert_called_with(87)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 90)
+        self.assertEqual(core.mixer.set_volume.call_count, 28)
+        core.mixer.set_volume.assert_called_with(90)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 94)
+        self.assertEqual(core.mixer.set_volume.call_count, 29)
+        core.mixer.set_volume.assert_called_with(94)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 97)
+        self.assertEqual(core.mixer.set_volume.call_count, 30)
+        core.mixer.set_volume.assert_called_with(97)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 100)
+        self.assertEqual(core.mixer.set_volume.call_count, 31)
+        core.mixer.set_volume.assert_called_with(100)
         self.assertEqual(threading.active_count(), threadcount)
 
         time.sleep(5)  # More than 3x increase step time
-        self.assertEqual(core.playback.volume, 100)
+        self.assertEqual(core.mixer.set_volume.call_count, 31)
+        core.mixer.set_volume.assert_called_with(100)
         self.assertEqual(threading.active_count(), threadcount)
 
     def test03_adjust_volume__100_30_intervened(self):
@@ -466,51 +510,62 @@ def test03_adjust_volume__100_30_intervened(self):
 
         am.adjust_volume(100, 30, 0)
 
-        self.assertEqual(core.playback.volume, 3)
+        core.mixer.set_volume.assert_called_once_with(3)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1.2)  # First step has additional 0.2 seconds to prevent race conditions
-        self.assertEqual(core.playback.volume, 6)
+        self.assertEqual(core.mixer.set_volume.call_count, 2)
+        core.mixer.set_volume.assert_called_with(6)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 10)
+        self.assertEqual(core.mixer.set_volume.call_count, 3)
+        core.mixer.set_volume.assert_called_with(10)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 13)
+        self.assertEqual(core.mixer.set_volume.call_count, 4)
+        core.mixer.set_volume.assert_called_with(13)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 16)
+        self.assertEqual(core.mixer.set_volume.call_count, 5)
+        core.mixer.set_volume.assert_called_with(16)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 19)
+        self.assertEqual(core.mixer.set_volume.call_count, 6)
+        core.mixer.set_volume.assert_called_with(19)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 23)
+        self.assertEqual(core.mixer.set_volume.call_count, 7)
+        core.mixer.set_volume.assert_called_with(23)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 26)
+        self.assertEqual(core.mixer.set_volume.call_count, 8)
+        core.mixer.set_volume.assert_called_with(26)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 29)
+        self.assertEqual(core.mixer.set_volume.call_count, 9)
+        core.mixer.set_volume.assert_called_with(29)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 32)
+        self.assertEqual(core.mixer.set_volume.call_count, 10)
+        core.mixer.set_volume.assert_called_with(32)
         time.sleep(1)
-        self.assertEqual(core.playback.volume, 35)
+        self.assertEqual(core.mixer.set_volume.call_count, 11)
+        core.mixer.set_volume.assert_called_with(35)
         self.assertEqual(threading.active_count(), threadcount + 1)
 
-        core.playback.volume = mock.Mock()
-        core.playback.volume.get.side_effect = lambda: 14  # Intervention: set volume to 14
+        core.mixer.set_volume(14)
+        core.mixer.get_volume().get.side_effect = lambda: 14  # Intervention: set volume to 14
         self.assertEqual(threading.active_count(), threadcount + 1)
 
         time.sleep(1)
-        self.assertIsInstance(core.playback.volume, mock.Mock)
-        self.assertEqual(core.playback.volume.get(), 14)
+        self.assertEqual(core.mixer.set_volume.call_count, 12)
+        core.mixer.set_volume.assert_called_with(14)
         self.assertEqual(threading.active_count(), threadcount)
 
         time.sleep(5)  # More than 3x increase step time
-        self.assertIsInstance(core.playback.volume, mock.Mock)
-        self.assertEqual(core.playback.volume.get(), 14)
+        self.assertEqual(core.mixer.set_volume.call_count, 12)
+        core.mixer.set_volume.assert_called_with(14)
         self.assertEqual(threading.active_count(), threadcount)
 
     def test04__integration_1(self):
         core = mock.Mock()
         playlist = 'Playlist URI'
-        core.playback.state.get.side_effect = lambda: PlaybackState.PLAYING
-        core.playback.time_position.get.side_effect = lambda: 234
+        core.playback.get_state().get.side_effect = lambda: PlaybackState.PLAYING
+        core.playback.get_time_position().get.side_effect = lambda: 234
         core.playlists.lookup('Playlist URI').get().tracks = 'Tracks 811, 821, 823, 827, 829, 839'
+        core.tracklist.get_length().get.side_effect = lambda: 4
         self.assertEqual(core.playlists.lookup.call_count, 1)  # First call when setting up the Mock
         threadcount = threading.active_count()
 
@@ -529,7 +584,7 @@ def test04__integration_1(self):
         # Test when set
         self.assertTrue(am.is_set())
         self.assertEqual(threading.active_count(), threadcount + 1)
-        self.assertEqual(am.get_ring_time(), b'07:59')
+        self.assertEqual(am.get_ring_time(), '07:59')
         self.assertFalse(am.random_mode)
         self.assertEqual(am.volume, 41)
         self.assertEqual(am.volume_increase_seconds, 83)
@@ -577,12 +632,12 @@ def test04__integration_1(self):
         time.sleep(29)
         self.assertTrue(am.is_set())
         self.assertEqual(threading.active_count(), threadcount + 1)
-        self.assertIsInstance(core.tracklist.consume, mock.Mock)
-        self.assertIsInstance(core.tracklist.single, mock.Mock)
-        self.assertIsInstance(core.tracklist.repeat, mock.Mock)
-        self.assertIsInstance(core.tracklist.random, mock.Mock)
-        self.assertIsInstance(core.playback.mute, mock.Mock)
-        self.assertIsInstance(core.playback.volume, mock.Mock)
+        self.assertEqual(core.tracklist.set_consume.call_count, 0)
+        self.assertEqual(core.tracklist.set_single.call_count, 0)
+        self.assertEqual(core.tracklist.set_repeat.call_count, 0)
+        self.assertEqual(core.tracklist.set_random.call_count, 0)
+        self.assertEqual(core.mixer.set_mute.call_count, 0)
+        self.assertEqual(core.mixer.set_volume.call_count, 0)
         self.assertEqual(core.playback.stop.call_count, 0)
         self.assertEqual(core.tracklist.clear.call_count, 0)
         self.assertEqual(core.tracklist.add.call_count, 0)
@@ -594,12 +649,15 @@ def test04__integration_1(self):
         time.sleep(8)
         self.assertFalse(am.is_set())
         self.assertEqual(threading.active_count(), threadcount + 1)  # Additional thread is created by adjust_volume()
-        self.assertEqual(core.tracklist.consume, False)
-        self.assertEqual(core.tracklist.single, False)
-        self.assertEqual(core.tracklist.repeat, True)
-        self.assertEqual(core.tracklist.random, True)
-        self.assertEqual(core.playback.mute, False)
-        self.assertEqual(core.playback.volume, 1)  # First step of gradual volume increasing
+
+        core.tracklist.set_consume.assert_called_once_with(False)
+        core.tracklist.set_single.assert_called_once_with(False)
+        core.tracklist.set_repeat.assert_called_once_with(True)
+        core.tracklist.set_random.assert_called_once_with(True)
+        core.mixer.set_mute.assert_called_once_with(False)
+        self.assertEqual(core.mixer.set_volume.call_count, 2)
+        core.mixer.set_volume.assert_called_with(1)  # First step of gradual volume increasing
+
         core.playback.stop.assert_called_once_with()
         core.tracklist.clear.assert_called_once_with()
         core.tracklist.add.assert_called_once_with('Tracks 811, 821, 823, 827, 829, 839')
@@ -609,16 +667,20 @@ def test04__integration_1(self):
 
         # Further tests of gradual volume increasing
         time.sleep(5.67)  # Race conditions already prevented by previous sleep()
-        self.assertEqual(core.playback.volume, 2)
+        self.assertEqual(core.mixer.set_volume.call_count, 3)
+        core.mixer.set_volume.assert_called_with(2)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(5.67)
-        self.assertEqual(core.playback.volume, 2)
+        self.assertEqual(core.mixer.set_volume.call_count, 4)
+        core.mixer.set_volume.assert_called_with(2)
         self.assertEqual(threading.active_count(), threadcount + 1)
         time.sleep(5.67)
-        self.assertEqual(core.playback.volume, 3)
+        self.assertEqual(core.mixer.set_volume.call_count, 5)
+        core.mixer.set_volume.assert_called_with(3)
         self.assertEqual(threading.active_count(), threadcount)
         time.sleep(20)  # More than 3x increase step time
-        self.assertEqual(core.playback.volume, 3)
+        self.assertEqual(core.mixer.set_volume.call_count, 5)
+        core.mixer.set_volume.assert_called_with(3)
         self.assertEqual(threading.active_count(), threadcount)
 
         # Test alarm cancellation after alarm has been started
@@ -633,7 +695,7 @@ def test04__integration_1(self):
         # Test when set
         self.assertTrue(am.is_set())
         self.assertEqual(threading.active_count(), threadcount + 1)
-        self.assertEqual(am.get_ring_time(), b'07:59')
+        self.assertEqual(am.get_ring_time(), '07:59')
         self.assertFalse(am.random_mode)
         self.assertEqual(am.volume, 41)
         self.assertEqual(am.volume_increase_seconds, 83)

From 3607817c0a6fed4b5f4e54b0fd0ba7878c532313 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Sat, 21 Mar 2020 18:29:23 +0200
Subject: [PATCH 11/12] Update requirements

---
 .travis.yml | 4 +++-
 setup.py    | 3 ++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index e2ead9f..c629f11 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,6 @@
 language: python
-sudo: true
+os: linux
+dist: bionic
 
 python:
   - "3.7"
@@ -9,6 +10,7 @@ env:
   - TOX_ENV=flake8
 
 before_install:
+  # Mock Python gi package
   - export PYUSRSITEDIR=$(python -m site --user-site)
   - mkdir -p $PYUSRSITEDIR
   - "echo \"import sys; import mock; sys.modules['gi'] = mock.Mock(); sys.modules['gi.repository'] = mock.Mock(); sys.modules['gi.repository'].Gst.version.side_effect = lambda: (1, 14, 0)\" > ${PYUSRSITEDIR}/usercustomize.py"
diff --git a/setup.py b/setup.py
index 74b105d..b9e9b5f 100644
--- a/setup.py
+++ b/setup.py
@@ -23,6 +23,7 @@ def get_version(filename):
     packages=find_packages(exclude=['tests', 'tests.*']),
     zip_safe=False,
     include_package_data=True,
+    python_requires='>= 3.7',
     install_requires=[
         'setuptools',
         'Mopidy >= 3.0',
@@ -44,7 +45,7 @@ def get_version(filename):
         'Intended Audience :: End Users/Desktop',
         'License :: OSI Approved :: Apache Software License',
         'Operating System :: OS Independent',
-        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 3',
         'Topic :: Multimedia :: Sound/Audio :: Players',
     ],
 )

From 5e3b1fda41c54f3e87edb78fedb691cc618a98b7 Mon Sep 17 00:00:00 2001
From: Davis Mosenkovs <davikovs@gmail.com>
Date: Sat, 21 Mar 2020 20:42:50 +0200
Subject: [PATCH 12/12] Version 0.1.8

---
 README.rst                    | 7 ++++++-
 mopidy_alarmclock/__init__.py | 2 +-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/README.rst b/README.rst
index e4aa933..d6db011 100644
--- a/README.rst
+++ b/README.rst
@@ -62,7 +62,7 @@ License
 ::
 
    Copyright 2014 Mathieu Xhonneux
-   Copyright 2015-2018 Davis Mosenkovs
+   Copyright 2015-2020 Davis Mosenkovs
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -88,6 +88,11 @@ Project resources
 Changelog
 =========
 
+v0.1.8
+----------------------------------------
+
+- Upgraded to Mopidy 3.0+ and Python 3.7+.
+
 v0.1.7
 ----------------------------------------
 
diff --git a/mopidy_alarmclock/__init__.py b/mopidy_alarmclock/__init__.py
index b2b16c5..e90223f 100644
--- a/mopidy_alarmclock/__init__.py
+++ b/mopidy_alarmclock/__init__.py
@@ -6,7 +6,7 @@
 from .http import MessageStore, factory_decorator
 
 
-__version__ = '0.1.7'
+__version__ = '0.1.8'
 
 
 class Extension(ext.Extension):