From 4722828c8f7997b0bfb55aee3cdc304a34ef14fd Mon Sep 17 00:00:00 2001 From: Stein Magnus Jodal Date: Sun, 22 Aug 2010 20:40:15 +0200 Subject: [PATCH] Split backend tests into multiple files --- tests/backends/base/__init__.py | 9 + tests/backends/base/current_playlist.py | 256 +++++++++ tests/backends/base/library.py | 158 +++++ .../backends/base/{backend.py => playback.py} | 540 +----------------- tests/backends/base/stored_playlists.py | 113 ++++ .../libspotify/backend_integrationtest.py | 22 +- tests/backends/local/__init__.py | 6 + tests/backends/local/current_playlist_test.py | 31 + tests/backends/local/library_test.py | 32 ++ tests/backends/local/playback_test.py | 58 ++ ...ckend_test.py => stored_playlists_test.py} | 96 +--- 11 files changed, 688 insertions(+), 633 deletions(-) create mode 100644 tests/backends/base/current_playlist.py create mode 100644 tests/backends/base/library.py rename tests/backends/base/{backend.py => playback.py} (60%) create mode 100644 tests/backends/base/stored_playlists.py create mode 100644 tests/backends/local/current_playlist_test.py create mode 100644 tests/backends/local/library_test.py create mode 100644 tests/backends/local/playback_test.py rename tests/backends/local/{backend_test.py => stored_playlists_test.py} (50%) diff --git a/tests/backends/base/__init__.py b/tests/backends/base/__init__.py index e69de29b..29f010e1 100644 --- a/tests/backends/base/__init__.py +++ b/tests/backends/base/__init__.py @@ -0,0 +1,9 @@ +def populate_playlist(func): + def wrapper(self): + for track in self.tracks: + self.backend.current_playlist.add(track) + return func(self) + + wrapper.__name__ = func.__name__ + wrapper.__doc__ = func.__doc__ + return wrapper diff --git a/tests/backends/base/current_playlist.py b/tests/backends/base/current_playlist.py new file mode 100644 index 00000000..1b312c2f --- /dev/null +++ b/tests/backends/base/current_playlist.py @@ -0,0 +1,256 @@ +import multiprocessing +import random + +from mopidy import settings +from mopidy.mixers.dummy import DummyMixer +from mopidy.models import Playlist, Track +from mopidy.utils import get_class + +from tests.backends.base import populate_playlist + +class BaseCurrentPlaylistControllerTest(object): + tracks = [] + + def setUp(self): + self.output_queue = multiprocessing.Queue() + self.core_queue = multiprocessing.Queue() + self.output = get_class(settings.OUTPUT)( + self.core_queue, self.output_queue) + self.backend = self.backend_class( + self.core_queue, self.output_queue, DummyMixer) + self.controller = self.backend.current_playlist + self.playback = self.backend.playback + + assert len(self.tracks) == 3, 'Need three tracks to run tests.' + + def tearDown(self): + self.backend.destroy() + self.output.destroy() + + def test_add(self): + for track in self.tracks: + cp_track = self.controller.add(track) + self.assertEqual(track, self.controller.tracks[-1]) + self.assertEqual(cp_track, self.controller.cp_tracks[-1]) + self.assertEqual(track, cp_track[1]) + + def test_add_at_position(self): + for track in self.tracks[:-1]: + cp_track = self.controller.add(track, 0) + self.assertEqual(track, self.controller.tracks[0]) + self.assertEqual(cp_track, self.controller.cp_tracks[0]) + self.assertEqual(track, cp_track[1]) + + @populate_playlist + def test_add_at_position_outside_of_playlist(self): + test = lambda: self.controller.add(self.tracks[0], len(self.tracks)+2) + self.assertRaises(AssertionError, test) + + @populate_playlist + def test_get_by_cpid(self): + cp_track = self.controller.cp_tracks[1] + self.assertEqual(cp_track, self.controller.get(cpid=cp_track[0])) + + @populate_playlist + def test_get_by_uri(self): + cp_track = self.controller.cp_tracks[1] + self.assertEqual(cp_track, self.controller.get(uri=cp_track[1].uri)) + + @populate_playlist + def test_get_by_uri_raises_error_for_invalid_uri(self): + test = lambda: self.controller.get(uri='foobar') + self.assertRaises(LookupError, test) + + @populate_playlist + def test_clear(self): + self.controller.clear() + self.assertEqual(len(self.controller.tracks), 0) + + def test_clear_empty_playlist(self): + self.controller.clear() + self.assertEqual(len(self.controller.tracks), 0) + + @populate_playlist + def test_clear_when_playing(self): + self.playback.play() + self.assertEqual(self.playback.state, self.playback.PLAYING) + self.controller.clear() + self.assertEqual(self.playback.state, self.playback.STOPPED) + + def test_get_by_uri_returns_unique_match(self): + track = Track(uri='a') + self.controller.append([Track(uri='z'), track, Track(uri='y')]) + self.assertEqual(track, self.controller.get(uri='a')[1]) + + def test_get_by_uri_raises_error_if_multiple_matches(self): + track = Track(uri='a') + self.controller.append([Track(uri='z'), track, track]) + try: + self.controller.get(uri='a') + self.fail(u'Should raise LookupError if multiple matches') + except LookupError as e: + self.assertEqual(u'"uri=a" match multiple tracks', e[0]) + + def test_get_by_uri_raises_error_if_no_match(self): + self.controller.playlist = Playlist( + tracks=[Track(uri='z'), Track(uri='y')]) + try: + self.controller.get(uri='a') + self.fail(u'Should raise LookupError if no match') + except LookupError as e: + self.assertEqual(u'"uri=a" match no tracks', e[0]) + + def test_get_by_multiple_criteria_returns_elements_matching_all(self): + track1 = Track(uri='a', name='x') + track2 = Track(uri='b', name='x') + track3 = Track(uri='b', name='y') + self.controller.append([track1, track2, track3]) + self.assertEqual(track1, self.controller.get(uri='a', name='x')[1]) + self.assertEqual(track2, self.controller.get(uri='b', name='x')[1]) + self.assertEqual(track3, self.controller.get(uri='b', name='y')[1]) + + def test_get_by_criteria_that_is_not_present_in_all_elements(self): + track1 = Track() + track2 = Track(uri='b') + track3 = Track() + self.controller.append([track1, track2, track3]) + self.assertEqual(track2, self.controller.get(uri='b')[1]) + + def test_append_appends_to_the_current_playlist(self): + self.controller.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(len(self.controller.tracks), 2) + self.controller.append([Track(uri='c'), Track(uri='d')]) + self.assertEqual(len(self.controller.tracks), 4) + self.assertEqual(self.controller.tracks[0].uri, 'a') + self.assertEqual(self.controller.tracks[1].uri, 'b') + self.assertEqual(self.controller.tracks[2].uri, 'c') + self.assertEqual(self.controller.tracks[3].uri, 'd') + + def test_append_does_not_reset_version(self): + version = self.controller.version + self.controller.append([]) + self.assertEqual(self.controller.version, version + 1) + + @populate_playlist + def test_append_preserves_playing_state(self): + self.playback.play() + track = self.playback.current_track + self.controller.append(self.controller.tracks[1:2]) + self.assertEqual(self.playback.state, self.playback.PLAYING) + self.assertEqual(self.playback.current_track, track) + + @populate_playlist + def test_append_preserves_stopped_state(self): + self.controller.append(self.controller.tracks[1:2]) + self.assertEqual(self.playback.state, self.playback.STOPPED) + self.assertEqual(self.playback.current_track, None) + + @populate_playlist + def test_move_single(self): + self.controller.move(0, 0, 2) + + tracks = self.controller.tracks + self.assertEqual(tracks[2], self.tracks[0]) + + @populate_playlist + def test_move_group(self): + self.controller.move(0, 2, 1) + + tracks = self.controller.tracks + self.assertEqual(tracks[1], self.tracks[0]) + self.assertEqual(tracks[2], self.tracks[1]) + + @populate_playlist + def test_moving_track_outside_of_playlist(self): + tracks = len(self.controller.tracks) + test = lambda: self.controller.move(0, 0, tracks+5) + self.assertRaises(AssertionError, test) + + @populate_playlist + def test_move_group_outside_of_playlist(self): + tracks = len(self.controller.tracks) + test = lambda: self.controller.move(0, 2, tracks+5) + self.assertRaises(AssertionError, test) + + @populate_playlist + def test_move_group_out_of_range(self): + tracks = len(self.controller.tracks) + test = lambda: self.controller.move(tracks+2, tracks+3, 0) + self.assertRaises(AssertionError, test) + + @populate_playlist + def test_move_group_invalid_group(self): + test = lambda: self.controller.move(2, 1, 0) + self.assertRaises(AssertionError, test) + + def test_tracks_attribute_is_immutable(self): + tracks1 = self.controller.tracks + tracks2 = self.controller.tracks + self.assertNotEqual(id(tracks1), id(tracks2)) + + @populate_playlist + def test_remove(self): + track1 = self.controller.tracks[1] + track2 = self.controller.tracks[2] + version = self.controller.version + self.controller.remove(uri=track1.uri) + self.assert_(version < self.controller.version) + self.assert_(track1 not in self.controller.tracks) + self.assertEqual(track2, self.controller.tracks[1]) + + @populate_playlist + def test_removing_track_that_does_not_exist(self): + test = lambda: self.controller.remove(uri='/nonexistant') + self.assertRaises(LookupError, test) + + def test_removing_from_empty_playlist(self): + test = lambda: self.controller.remove(uri='/nonexistant') + self.assertRaises(LookupError, test) + + @populate_playlist + def test_shuffle(self): + random.seed(1) + self.controller.shuffle() + + shuffled_tracks = self.controller.tracks + + self.assertNotEqual(self.tracks, shuffled_tracks) + self.assertEqual(set(self.tracks), set(shuffled_tracks)) + + @populate_playlist + def test_shuffle_subset(self): + random.seed(1) + self.controller.shuffle(1, 3) + + shuffled_tracks = self.controller.tracks + + self.assertNotEqual(self.tracks, shuffled_tracks) + self.assertEqual(self.tracks[0], shuffled_tracks[0]) + self.assertEqual(set(self.tracks), set(shuffled_tracks)) + + @populate_playlist + def test_shuffle_invalid_subset(self): + test = lambda: self.controller.shuffle(3, 1) + self.assertRaises(AssertionError, test) + + @populate_playlist + def test_shuffle_superset(self): + tracks = len(self.controller.tracks) + test = lambda: self.controller.shuffle(1, tracks+5) + self.assertRaises(AssertionError, test) + + @populate_playlist + def test_shuffle_open_subset(self): + random.seed(1) + self.controller.shuffle(1) + + shuffled_tracks = self.controller.tracks + + self.assertNotEqual(self.tracks, shuffled_tracks) + self.assertEqual(self.tracks[0], shuffled_tracks[0]) + self.assertEqual(set(self.tracks), set(shuffled_tracks)) + + def test_version(self): + version = self.controller.version + self.controller.append([]) + self.assert_(version < self.controller.version) diff --git a/tests/backends/base/library.py b/tests/backends/base/library.py new file mode 100644 index 00000000..1239bd08 --- /dev/null +++ b/tests/backends/base/library.py @@ -0,0 +1,158 @@ +from mopidy.mixers.dummy import DummyMixer +from mopidy.models import Playlist, Track, Album, Artist + +from tests import SkipTest, data_folder + +class BaseLibraryControllerTest(object): + artists = [Artist(name='artist1'), Artist(name='artist2'), Artist()] + albums = [Album(name='album1', artists=artists[:1]), + Album(name='album2', artists=artists[1:2]), + Album()] + tracks = [Track(name='track1', length=4000, artists=artists[:1], + album=albums[0], uri='file://' + data_folder('uri1')), + Track(name='track2', length=4000, artists=artists[1:2], + album=albums[1], uri='file://' + data_folder('uri2')), + Track()] + + def setUp(self): + self.backend = self.backend_class(mixer_class=DummyMixer) + self.library = self.backend.library + + def tearDown(self): + self.backend.destroy() + + def test_refresh(self): + self.library.refresh() + + def test_refresh_uri(self): + raise SkipTest + + def test_refresh_missing_uri(self): + raise SkipTest + + def test_lookup(self): + track = self.library.lookup(self.tracks[0].uri) + self.assertEqual(track, self.tracks[0]) + + def test_lookup_unknown_track(self): + test = lambda: self.library.lookup('fake uri') + self.assertRaises(LookupError, test) + + def test_find_exact_no_hits(self): + result = self.library.find_exact(track=['unknown track']) + self.assertEqual(result, Playlist()) + + result = self.library.find_exact(artist=['unknown artist']) + self.assertEqual(result, Playlist()) + + result = self.library.find_exact(album=['unknown artist']) + self.assertEqual(result, Playlist()) + + def test_find_exact_artist(self): + result = self.library.find_exact(artist=['artist1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + + result = self.library.find_exact(artist=['artist2']) + self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) + + def test_find_exact_track(self): + result = self.library.find_exact(track=['track1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + + result = self.library.find_exact(track=['track2']) + self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) + + def test_find_exact_album(self): + result = self.library.find_exact(album=['album1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + + result = self.library.find_exact(album=['album2']) + self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) + + def test_find_exact_wrong_type(self): + test = lambda: self.library.find_exact(wrong=['test']) + self.assertRaises(LookupError, test) + + def test_find_exact_with_empty_query(self): + test = lambda: self.library.find_exact(artist=['']) + self.assertRaises(LookupError, test) + + test = lambda: self.library.find_exact(track=['']) + self.assertRaises(LookupError, test) + + test = lambda: self.library.find_exact(album=['']) + self.assertRaises(LookupError, test) + + def test_search_no_hits(self): + result = self.library.search(track=['unknown track']) + self.assertEqual(result, Playlist()) + + result = self.library.search(artist=['unknown artist']) + self.assertEqual(result, Playlist()) + + result = self.library.search(album=['unknown artist']) + self.assertEqual(result, Playlist()) + + result = self.library.search(uri=['unknown']) + self.assertEqual(result, Playlist()) + + result = self.library.search(any=['unknown']) + self.assertEqual(result, Playlist()) + + def test_search_artist(self): + result = self.library.search(artist=['Tist1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + + result = self.library.search(artist=['Tist2']) + self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) + + def test_search_track(self): + result = self.library.search(track=['Rack1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + + result = self.library.search(track=['Rack2']) + self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) + + def test_search_album(self): + result = self.library.search(album=['Bum1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + + result = self.library.search(album=['Bum2']) + self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) + + def test_search_uri(self): + result = self.library.search(uri=['RI1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + + result = self.library.search(uri=['RI2']) + self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) + + def test_search_any(self): + result = self.library.search(any=['Tist1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + result = self.library.search(any=['Rack1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + result = self.library.search(any=['Bum1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + result = self.library.search(any=['RI1']) + self.assertEqual(result, Playlist(tracks=self.tracks[:1])) + + def test_search_wrong_type(self): + test = lambda: self.library.search(wrong=['test']) + self.assertRaises(LookupError, test) + + def test_search_with_empty_query(self): + test = lambda: self.library.search(artist=['']) + self.assertRaises(LookupError, test) + + test = lambda: self.library.search(track=['']) + self.assertRaises(LookupError, test) + + test = lambda: self.library.search(album=['']) + self.assertRaises(LookupError, test) + + test = lambda: self.library.search(uri=['']) + self.assertRaises(LookupError, test) + + test = lambda: self.library.search(any=['']) + self.assertRaises(LookupError, test) diff --git a/tests/backends/base/backend.py b/tests/backends/base/playback.py similarity index 60% rename from tests/backends/base/backend.py rename to tests/backends/base/playback.py index e9b78453..f8e9dd87 100644 --- a/tests/backends/base/backend.py +++ b/tests/backends/base/playback.py @@ -1,289 +1,25 @@ import multiprocessing -import os import random -import shutil -import tempfile import time from mopidy import settings from mopidy.mixers.dummy import DummyMixer -from mopidy.models import Playlist, Track, Album, Artist +from mopidy.models import Track from mopidy.utils import get_class -from tests import SkipTest, data_folder - -__all__ = ['BaseCurrentPlaylistControllerTest', - 'BasePlaybackControllerTest', - 'BaseStoredPlaylistsControllerTest', - 'BaseLibraryControllerTest'] - -def populate_playlist(func): - def wrapper(self): - for track in self.tracks: - self.backend.current_playlist.add(track) - return func(self) - - wrapper.__name__ = func.__name__ - wrapper.__doc__ = func.__doc__ - return wrapper - - -class BaseCurrentPlaylistControllerTest(object): - tracks = [] - backend_class = None - - def setUp(self): - self.output_queue = multiprocessing.Queue() - self.core_queue = multiprocessing.Queue() - self.output = get_class(settings.OUTPUT)(self.core_queue, self.output_queue) - self.backend = self.backend_class(self.core_queue, self.output_queue, DummyMixer) - self.controller = self.backend.current_playlist - self.playback = self.backend.playback - - assert len(self.tracks) == 3, 'Need three tracks to run tests.' - - def tearDown(self): - self.backend.destroy() - self.output.destroy() - - def test_add(self): - for track in self.tracks: - cp_track = self.controller.add(track) - self.assertEqual(track, self.controller.tracks[-1]) - self.assertEqual(cp_track, self.controller.cp_tracks[-1]) - self.assertEqual(track, cp_track[1]) - - def test_add_at_position(self): - for track in self.tracks[:-1]: - cp_track = self.controller.add(track, 0) - self.assertEqual(track, self.controller.tracks[0]) - self.assertEqual(cp_track, self.controller.cp_tracks[0]) - self.assertEqual(track, cp_track[1]) - - @populate_playlist - def test_add_at_position_outside_of_playlist(self): - test = lambda: self.controller.add(self.tracks[0], len(self.tracks)+2) - self.assertRaises(AssertionError, test) - - @populate_playlist - def test_get_by_cpid(self): - cp_track = self.controller.cp_tracks[1] - self.assertEqual(cp_track, self.controller.get(cpid=cp_track[0])) - - @populate_playlist - def test_get_by_uri(self): - cp_track = self.controller.cp_tracks[1] - self.assertEqual(cp_track, self.controller.get(uri=cp_track[1].uri)) - - @populate_playlist - def test_get_by_uri_raises_error_for_invalid_uri(self): - test = lambda: self.controller.get(uri='foobar') - self.assertRaises(LookupError, test) - - @populate_playlist - def test_clear(self): - self.controller.clear() - self.assertEqual(len(self.controller.tracks), 0) - - def test_clear_empty_playlist(self): - self.controller.clear() - self.assertEqual(len(self.controller.tracks), 0) - - @populate_playlist - def test_clear_when_playing(self): - self.playback.play() - self.assertEqual(self.playback.state, self.playback.PLAYING) - self.controller.clear() - self.assertEqual(self.playback.state, self.playback.STOPPED) - - def test_get_by_uri_returns_unique_match(self): - track = Track(uri='a') - self.controller.append([Track(uri='z'), track, Track(uri='y')]) - self.assertEqual(track, self.controller.get(uri='a')[1]) - - def test_get_by_uri_raises_error_if_multiple_matches(self): - track = Track(uri='a') - self.controller.append([Track(uri='z'), track, track]) - try: - self.controller.get(uri='a') - self.fail(u'Should raise LookupError if multiple matches') - except LookupError as e: - self.assertEqual(u'"uri=a" match multiple tracks', e[0]) - - def test_get_by_uri_raises_error_if_no_match(self): - self.controller.playlist = Playlist( - tracks=[Track(uri='z'), Track(uri='y')]) - try: - self.controller.get(uri='a') - self.fail(u'Should raise LookupError if no match') - except LookupError as e: - self.assertEqual(u'"uri=a" match no tracks', e[0]) - - def test_get_by_multiple_criteria_returns_elements_matching_all(self): - track1 = Track(uri='a', name='x') - track2 = Track(uri='b', name='x') - track3 = Track(uri='b', name='y') - self.controller.append([track1, track2, track3]) - self.assertEqual(track1, self.controller.get(uri='a', name='x')[1]) - self.assertEqual(track2, self.controller.get(uri='b', name='x')[1]) - self.assertEqual(track3, self.controller.get(uri='b', name='y')[1]) - - def test_get_by_criteria_that_is_not_present_in_all_elements(self): - track1 = Track() - track2 = Track(uri='b') - track3 = Track() - self.controller.append([track1, track2, track3]) - self.assertEqual(track2, self.controller.get(uri='b')[1]) - - def test_append_appends_to_the_current_playlist(self): - self.controller.append([Track(uri='a'), Track(uri='b')]) - self.assertEqual(len(self.controller.tracks), 2) - self.controller.append([Track(uri='c'), Track(uri='d')]) - self.assertEqual(len(self.controller.tracks), 4) - self.assertEqual(self.controller.tracks[0].uri, 'a') - self.assertEqual(self.controller.tracks[1].uri, 'b') - self.assertEqual(self.controller.tracks[2].uri, 'c') - self.assertEqual(self.controller.tracks[3].uri, 'd') - - def test_append_does_not_reset_version(self): - version = self.controller.version - self.controller.append([]) - self.assertEqual(self.controller.version, version + 1) - - @populate_playlist - def test_append_preserves_playing_state(self): - self.playback.play() - track = self.playback.current_track - self.controller.append(self.controller.tracks[1:2]) - self.assertEqual(self.playback.state, self.playback.PLAYING) - self.assertEqual(self.playback.current_track, track) - - @populate_playlist - def test_append_preserves_stopped_state(self): - self.controller.append(self.controller.tracks[1:2]) - self.assertEqual(self.playback.state, self.playback.STOPPED) - self.assertEqual(self.playback.current_track, None) - - @populate_playlist - def test_move_single(self): - self.controller.move(0, 0, 2) - - tracks = self.controller.tracks - self.assertEqual(tracks[2], self.tracks[0]) - - @populate_playlist - def test_move_group(self): - self.controller.move(0, 2, 1) - - tracks = self.controller.tracks - self.assertEqual(tracks[1], self.tracks[0]) - self.assertEqual(tracks[2], self.tracks[1]) - - @populate_playlist - def test_moving_track_outside_of_playlist(self): - tracks = len(self.controller.tracks) - test = lambda: self.controller.move(0, 0, tracks+5) - self.assertRaises(AssertionError, test) - - @populate_playlist - def test_move_group_outside_of_playlist(self): - tracks = len(self.controller.tracks) - test = lambda: self.controller.move(0, 2, tracks+5) - self.assertRaises(AssertionError, test) - - @populate_playlist - def test_move_group_out_of_range(self): - tracks = len(self.controller.tracks) - test = lambda: self.controller.move(tracks+2, tracks+3, 0) - self.assertRaises(AssertionError, test) - - @populate_playlist - def test_move_group_invalid_group(self): - test = lambda: self.controller.move(2, 1, 0) - self.assertRaises(AssertionError, test) - - def test_tracks_attribute_is_immutable(self): - tracks1 = self.controller.tracks - tracks2 = self.controller.tracks - self.assertNotEqual(id(tracks1), id(tracks2)) - - @populate_playlist - def test_remove(self): - track1 = self.controller.tracks[1] - track2 = self.controller.tracks[2] - version = self.controller.version - self.controller.remove(uri=track1.uri) - self.assert_(version < self.controller.version) - self.assert_(track1 not in self.controller.tracks) - self.assertEqual(track2, self.controller.tracks[1]) - - @populate_playlist - def test_removing_track_that_does_not_exist(self): - test = lambda: self.controller.remove(uri='/nonexistant') - self.assertRaises(LookupError, test) - - def test_removing_from_empty_playlist(self): - test = lambda: self.controller.remove(uri='/nonexistant') - self.assertRaises(LookupError, test) - - @populate_playlist - def test_shuffle(self): - random.seed(1) - self.controller.shuffle() - - shuffled_tracks = self.controller.tracks - - self.assertNotEqual(self.tracks, shuffled_tracks) - self.assertEqual(set(self.tracks), set(shuffled_tracks)) - - @populate_playlist - def test_shuffle_subset(self): - random.seed(1) - self.controller.shuffle(1, 3) - - shuffled_tracks = self.controller.tracks - - self.assertNotEqual(self.tracks, shuffled_tracks) - self.assertEqual(self.tracks[0], shuffled_tracks[0]) - self.assertEqual(set(self.tracks), set(shuffled_tracks)) - - @populate_playlist - def test_shuffle_invalid_subset(self): - test = lambda: self.controller.shuffle(3, 1) - self.assertRaises(AssertionError, test) - - @populate_playlist - def test_shuffle_superset(self): - tracks = len(self.controller.tracks) - test = lambda: self.controller.shuffle(1, tracks+5) - self.assertRaises(AssertionError, test) - - @populate_playlist - def test_shuffle_open_subset(self): - random.seed(1) - self.controller.shuffle(1) - - shuffled_tracks = self.controller.tracks - - self.assertNotEqual(self.tracks, shuffled_tracks) - self.assertEqual(self.tracks[0], shuffled_tracks[0]) - self.assertEqual(set(self.tracks), set(shuffled_tracks)) - - def test_version(self): - version = self.controller.version - self.controller.append([]) - self.assert_(version < self.controller.version) - +from tests import SkipTest +from tests.backends.base import populate_playlist class BasePlaybackControllerTest(object): tracks = [] - backend_class = None def setUp(self): self.output_queue = multiprocessing.Queue() self.core_queue = multiprocessing.Queue() - self.output = get_class(settings.OUTPUT)(self.core_queue, self.output_queue) - self.backend = self.backend_class(self.core_queue, self.output_queue, DummyMixer) + self.output = get_class(settings.OUTPUT)( + self.core_queue, self.output_queue) + self.backend = self.backend_class( + self.core_queue, self.output_queue, DummyMixer) self.playback = self.backend.playback self.current_playlist = self.backend.current_playlist @@ -1123,265 +859,3 @@ class BasePlaybackControllerTest(object): def test_playing_track_that_isnt_in_playlist(self): test = lambda: self.playback.play((17, Track())) self.assertRaises(AssertionError, test) - - -class BaseStoredPlaylistsControllerTest(object): - backend_class = None - - def setUp(self): - self.original_playlist_folder = settings.LOCAL_PLAYLIST_FOLDER - self.original_tag_cache = settings.LOCAL_TAG_CACHE - self.original_music_folder = settings.LOCAL_MUSIC_FOLDER - - settings.LOCAL_PLAYLIST_FOLDER = tempfile.mkdtemp() - settings.LOCAL_TAG_CACHE = data_folder('library_tag_cache') - settings.LOCAL_MUSIC_FOLDER = data_folder('') - - self.backend = self.backend_class(mixer_class=DummyMixer) - self.stored = self.backend.stored_playlists - - def tearDown(self): - self.backend.destroy() - - if os.path.exists(settings.LOCAL_PLAYLIST_FOLDER): - shutil.rmtree(settings.LOCAL_PLAYLIST_FOLDER) - - settings.LOCAL_PLAYLIST_FOLDER = self.original_playlist_folder - settings.LOCAL_TAG_CACHE = self.original_tag_cache - settings.LOCAL_MUSIC_FOLDER = self.original_music_folder - - def test_create(self): - playlist = self.stored.create('test') - self.assertEqual(playlist.name, 'test') - - def test_create_in_playlists(self): - playlist = self.stored.create('test') - self.assert_(self.stored.playlists) - self.assert_(playlist in self.stored.playlists) - - def test_playlists_empty_to_start_with(self): - self.assert_(not self.stored.playlists) - - def test_delete_non_existant_playlist(self): - self.stored.delete(Playlist()) - - def test_delete_playlist(self): - playlist = self.stored.create('test') - self.stored.delete(playlist) - self.assert_(not self.stored.playlists) - - def test_get_without_criteria(self): - test = self.stored.get - self.assertRaises(LookupError, test) - - def test_get_with_wrong_cirteria(self): - test = lambda: self.stored.get(name='foo') - self.assertRaises(LookupError, test) - - def test_get_with_right_criteria(self): - playlist1 = self.stored.create('test') - playlist2 = self.stored.get(name='test') - self.assertEqual(playlist1, playlist2) - - def test_get_by_name_returns_unique_match(self): - playlist = Playlist(name='b') - self.stored.playlists = [Playlist(name='a'), playlist] - self.assertEqual(playlist, self.stored.get(name='b')) - - def test_get_by_name_returns_first_of_multiple_matches(self): - playlist = Playlist(name='b') - self.stored.playlists = [ - playlist, Playlist(name='a'), Playlist(name='b')] - try: - self.stored.get(name='b') - self.fail(u'Should raise LookupError if multiple matches') - except LookupError as e: - self.assertEqual(u'"name=b" match multiple playlists', e[0]) - - def test_get_by_name_raises_keyerror_if_no_match(self): - self.stored.playlists = [Playlist(name='a'), Playlist(name='b')] - try: - self.stored.get(name='c') - self.fail(u'Should raise LookupError if no match') - except LookupError as e: - self.assertEqual(u'"name=c" match no playlists', e[0]) - - def test_lookup(self): - raise SkipTest - - def test_refresh(self): - raise SkipTest - - def test_rename(self): - playlist = self.stored.create('test') - self.stored.rename(playlist, 'test2') - self.stored.get(name='test2') - - def test_rename_unknown_playlist(self): - self.stored.rename(Playlist(), 'test2') - test = lambda: self.stored.get(name='test2') - self.assertRaises(LookupError, test) - - def test_save(self): - # FIXME should we handle playlists without names? - playlist = Playlist(name='test') - self.stored.save(playlist) - self.assert_(playlist in self.stored.playlists) - - def test_playlist_with_unknown_track(self): - raise SkipTest - - -class BaseLibraryControllerTest(object): - artists = [Artist(name='artist1'), Artist(name='artist2'), Artist()] - albums = [Album(name='album1', artists=artists[:1]), - Album(name='album2', artists=artists[1:2]), - Album()] - tracks = [Track(name='track1', length=4000, artists=artists[:1], - album=albums[0], uri='file://' + data_folder('uri1')), - Track(name='track2', length=4000, artists=artists[1:2], - album=albums[1], uri='file://' + data_folder('uri2')), - Track()] - - def setUp(self): - self.backend = self.backend_class(mixer_class=DummyMixer) - self.library = self.backend.library - - def tearDown(self): - self.backend.destroy() - - def test_refresh(self): - self.library.refresh() - - def test_refresh_uri(self): - raise SkipTest - - def test_refresh_missing_uri(self): - raise SkipTest - - def test_lookup(self): - track = self.library.lookup(self.tracks[0].uri) - self.assertEqual(track, self.tracks[0]) - - def test_lookup_unknown_track(self): - test = lambda: self.library.lookup('fake uri') - self.assertRaises(LookupError, test) - - def test_find_exact_no_hits(self): - result = self.library.find_exact(track=['unknown track']) - self.assertEqual(result, Playlist()) - - result = self.library.find_exact(artist=['unknown artist']) - self.assertEqual(result, Playlist()) - - result = self.library.find_exact(album=['unknown artist']) - self.assertEqual(result, Playlist()) - - def test_find_exact_artist(self): - result = self.library.find_exact(artist=['artist1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - - result = self.library.find_exact(artist=['artist2']) - self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) - - def test_find_exact_track(self): - result = self.library.find_exact(track=['track1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - - result = self.library.find_exact(track=['track2']) - self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) - - def test_find_exact_album(self): - result = self.library.find_exact(album=['album1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - - result = self.library.find_exact(album=['album2']) - self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) - - def test_find_exact_wrong_type(self): - test = lambda: self.library.find_exact(wrong=['test']) - self.assertRaises(LookupError, test) - - def test_find_exact_with_empty_query(self): - test = lambda: self.library.find_exact(artist=['']) - self.assertRaises(LookupError, test) - - test = lambda: self.library.find_exact(track=['']) - self.assertRaises(LookupError, test) - - test = lambda: self.library.find_exact(album=['']) - self.assertRaises(LookupError, test) - - def test_search_no_hits(self): - result = self.library.search(track=['unknown track']) - self.assertEqual(result, Playlist()) - - result = self.library.search(artist=['unknown artist']) - self.assertEqual(result, Playlist()) - - result = self.library.search(album=['unknown artist']) - self.assertEqual(result, Playlist()) - - result = self.library.search(uri=['unknown']) - self.assertEqual(result, Playlist()) - - result = self.library.search(any=['unknown']) - self.assertEqual(result, Playlist()) - - def test_search_artist(self): - result = self.library.search(artist=['Tist1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - - result = self.library.search(artist=['Tist2']) - self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) - - def test_search_track(self): - result = self.library.search(track=['Rack1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - - result = self.library.search(track=['Rack2']) - self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) - - def test_search_album(self): - result = self.library.search(album=['Bum1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - - result = self.library.search(album=['Bum2']) - self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) - - def test_search_uri(self): - result = self.library.search(uri=['RI1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - - result = self.library.search(uri=['RI2']) - self.assertEqual(result, Playlist(tracks=self.tracks[1:2])) - - def test_search_any(self): - result = self.library.search(any=['Tist1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - result = self.library.search(any=['Rack1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - result = self.library.search(any=['Bum1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - result = self.library.search(any=['RI1']) - self.assertEqual(result, Playlist(tracks=self.tracks[:1])) - - def test_search_wrong_type(self): - test = lambda: self.library.search(wrong=['test']) - self.assertRaises(LookupError, test) - - def test_search_with_empty_query(self): - test = lambda: self.library.search(artist=['']) - self.assertRaises(LookupError, test) - - test = lambda: self.library.search(track=['']) - self.assertRaises(LookupError, test) - - test = lambda: self.library.search(album=['']) - self.assertRaises(LookupError, test) - - test = lambda: self.library.search(uri=['']) - self.assertRaises(LookupError, test) - - test = lambda: self.library.search(any=['']) - self.assertRaises(LookupError, test) diff --git a/tests/backends/base/stored_playlists.py b/tests/backends/base/stored_playlists.py new file mode 100644 index 00000000..630898de --- /dev/null +++ b/tests/backends/base/stored_playlists.py @@ -0,0 +1,113 @@ +import os +import shutil +import tempfile + +from mopidy import settings +from mopidy.mixers.dummy import DummyMixer +from mopidy.models import Playlist + +from tests import SkipTest, data_folder + +class BaseStoredPlaylistsControllerTest(object): + def setUp(self): + self.original_playlist_folder = settings.LOCAL_PLAYLIST_FOLDER + self.original_tag_cache = settings.LOCAL_TAG_CACHE + self.original_music_folder = settings.LOCAL_MUSIC_FOLDER + + settings.LOCAL_PLAYLIST_FOLDER = tempfile.mkdtemp() + settings.LOCAL_TAG_CACHE = data_folder('library_tag_cache') + settings.LOCAL_MUSIC_FOLDER = data_folder('') + + self.backend = self.backend_class(mixer_class=DummyMixer) + self.stored = self.backend.stored_playlists + + def tearDown(self): + self.backend.destroy() + + if os.path.exists(settings.LOCAL_PLAYLIST_FOLDER): + shutil.rmtree(settings.LOCAL_PLAYLIST_FOLDER) + + settings.LOCAL_PLAYLIST_FOLDER = self.original_playlist_folder + settings.LOCAL_TAG_CACHE = self.original_tag_cache + settings.LOCAL_MUSIC_FOLDER = self.original_music_folder + + def test_create(self): + playlist = self.stored.create('test') + self.assertEqual(playlist.name, 'test') + + def test_create_in_playlists(self): + playlist = self.stored.create('test') + self.assert_(self.stored.playlists) + self.assert_(playlist in self.stored.playlists) + + def test_playlists_empty_to_start_with(self): + self.assert_(not self.stored.playlists) + + def test_delete_non_existant_playlist(self): + self.stored.delete(Playlist()) + + def test_delete_playlist(self): + playlist = self.stored.create('test') + self.stored.delete(playlist) + self.assert_(not self.stored.playlists) + + def test_get_without_criteria(self): + test = self.stored.get + self.assertRaises(LookupError, test) + + def test_get_with_wrong_cirteria(self): + test = lambda: self.stored.get(name='foo') + self.assertRaises(LookupError, test) + + def test_get_with_right_criteria(self): + playlist1 = self.stored.create('test') + playlist2 = self.stored.get(name='test') + self.assertEqual(playlist1, playlist2) + + def test_get_by_name_returns_unique_match(self): + playlist = Playlist(name='b') + self.stored.playlists = [Playlist(name='a'), playlist] + self.assertEqual(playlist, self.stored.get(name='b')) + + def test_get_by_name_returns_first_of_multiple_matches(self): + playlist = Playlist(name='b') + self.stored.playlists = [ + playlist, Playlist(name='a'), Playlist(name='b')] + try: + self.stored.get(name='b') + self.fail(u'Should raise LookupError if multiple matches') + except LookupError as e: + self.assertEqual(u'"name=b" match multiple playlists', e[0]) + + def test_get_by_name_raises_keyerror_if_no_match(self): + self.stored.playlists = [Playlist(name='a'), Playlist(name='b')] + try: + self.stored.get(name='c') + self.fail(u'Should raise LookupError if no match') + except LookupError as e: + self.assertEqual(u'"name=c" match no playlists', e[0]) + + def test_lookup(self): + raise SkipTest + + def test_refresh(self): + raise SkipTest + + def test_rename(self): + playlist = self.stored.create('test') + self.stored.rename(playlist, 'test2') + self.stored.get(name='test2') + + def test_rename_unknown_playlist(self): + self.stored.rename(Playlist(), 'test2') + test = lambda: self.stored.get(name='test2') + self.assertRaises(LookupError, test) + + def test_save(self): + # FIXME should we handle playlists without names? + playlist = Playlist(name='test') + self.stored.save(playlist) + self.assert_(playlist in self.stored.playlists) + + def test_playlist_with_unknown_track(self): + raise SkipTest diff --git a/tests/backends/libspotify/backend_integrationtest.py b/tests/backends/libspotify/backend_integrationtest.py index 1e7e9b97..8d1f0b0e 100644 --- a/tests/backends/libspotify/backend_integrationtest.py +++ b/tests/backends/libspotify/backend_integrationtest.py @@ -5,7 +5,12 @@ import unittest from mopidy.backends.libspotify import LibspotifyBackend from mopidy.models import Track -from tests.backends.base import * +from tests.backends.base.current_playlist import \ + BaseCurrentPlaylistControllerTest +from tests.backends.base.library import BaseLibraryControllerTest +from tests.backends.base.playback import BasePlaybackControllerTest +from tests.backends.base.stored_playlists import \ + BaseStoredPlaylistsControllerTest uris = [ 'spotify:track:6vqcpVcbI3Zu6sH3ieLDNt', @@ -15,28 +20,25 @@ uris = [ class LibspotifyCurrentPlaylistControllerTest( BaseCurrentPlaylistControllerTest, unittest.TestCase): - tracks = [Track(uri=uri, length=4464) for i, uri in enumerate(uris)] + backend_class = LibspotifyBackend + tracks = [Track(uri=uri, length=4464) for i, uri in enumerate(uris)] class LibspotifyPlaybackControllerTest( BasePlaybackControllerTest, unittest.TestCase): - tracks = [Track(uri=uri, length=4464) for i, uri in enumerate(uris)] + backend_class = LibspotifyBackend + tracks = [Track(uri=uri, length=4464) for i, uri in enumerate(uris)] class LibspotifyStoredPlaylistsControllerTest( BaseStoredPlaylistsControllerTest, unittest.TestCase): + backend_class = LibspotifyBackend class LibspotifyLibraryControllerTest( BaseLibraryControllerTest, unittest.TestCase): + backend_class = LibspotifyBackend - - -# TODO Plug this into the backend under test to avoid music output during -# testing. -class DummyAudioController(object): - def music_delivery(self, *args, **kwargs): - pass diff --git a/tests/backends/local/__init__.py b/tests/backends/local/__init__.py index e69de29b..60a1bd4d 100644 --- a/tests/backends/local/__init__.py +++ b/tests/backends/local/__init__.py @@ -0,0 +1,6 @@ +from mopidy.utils.path import path_to_uri + +from tests import data_folder + +song = data_folder('song%s.wav') +generate_song = lambda i: path_to_uri(song % i) diff --git a/tests/backends/local/current_playlist_test.py b/tests/backends/local/current_playlist_test.py new file mode 100644 index 00000000..01354a06 --- /dev/null +++ b/tests/backends/local/current_playlist_test.py @@ -0,0 +1,31 @@ +import unittest + +# FIXME Our Windows build server does not support GStreamer yet +import sys +if sys.platform == 'win32': + from tests import SkipTest + raise SkipTest + +from mopidy import settings +from mopidy.backends.local import LocalBackend +from mopidy.models import Track + +from tests.backends.base.current_playlist import \ + BaseCurrentPlaylistControllerTest +from tests.backends.local import generate_song + +class LocalCurrentPlaylistControllerTest(BaseCurrentPlaylistControllerTest, + unittest.TestCase): + + backend_class = LocalBackend + tracks = [Track(uri=generate_song(i), length=4464) + for i in range(1, 4)] + + def setUp(self): + self.original_backends = settings.BACKENDS + settings.BACKENDS = ('mopidy.backends.local.LocalBackend',) + super(LocalCurrentPlaylistControllerTest, self).setUp() + + def tearDown(self): + super(LocalCurrentPlaylistControllerTest, self).tearDown() + settings.BACKENDS = settings.original_backends diff --git a/tests/backends/local/library_test.py b/tests/backends/local/library_test.py new file mode 100644 index 00000000..75751e3d --- /dev/null +++ b/tests/backends/local/library_test.py @@ -0,0 +1,32 @@ +import unittest + +# FIXME Our Windows build server does not support GStreamer yet +import sys +if sys.platform == 'win32': + from tests import SkipTest + raise SkipTest + +from mopidy import settings +from mopidy.backends.local import LocalBackend + +from tests import data_folder +from tests.backends.base.library import BaseLibraryControllerTest + +class LocalLibraryControllerTest(BaseLibraryControllerTest, unittest.TestCase): + + backend_class = LocalBackend + + def setUp(self): + self.original_tag_cache = settings.LOCAL_TAG_CACHE + self.original_music_folder = settings.LOCAL_MUSIC_FOLDER + + settings.LOCAL_TAG_CACHE = data_folder('library_tag_cache') + settings.LOCAL_MUSIC_FOLDER = data_folder('') + + super(LocalLibraryControllerTest, self).setUp() + + def tearDown(self): + settings.LOCAL_TAG_CACHE = self.original_tag_cache + settings.LOCAL_MUSIC_FOLDER = self.original_music_folder + + super(LocalLibraryControllerTest, self).tearDown() diff --git a/tests/backends/local/playback_test.py b/tests/backends/local/playback_test.py new file mode 100644 index 00000000..4a385a9d --- /dev/null +++ b/tests/backends/local/playback_test.py @@ -0,0 +1,58 @@ +import unittest + +# FIXME Our Windows build server does not support GStreamer yet +import sys +if sys.platform == 'win32': + from tests import SkipTest + raise SkipTest + +from mopidy import settings +from mopidy.backends.local import LocalBackend +from mopidy.models import Track +from mopidy.utils.path import path_to_uri + +from tests import data_folder +from tests.backends.base.playback import BasePlaybackControllerTest +from tests.backends.local import generate_song + +class LocalPlaybackControllerTest(BasePlaybackControllerTest, + unittest.TestCase): + + backend_class = LocalBackend + tracks = [Track(uri=generate_song(i), length=4464) + for i in range(1, 4)] + + def setUp(self): + self.original_backends = settings.BACKENDS + settings.BACKENDS = ('mopidy.backends.local.LocalBackend',) + + super(LocalPlaybackControllerTest, self).setUp() + # Two tests does not work at all when using the fake sink + #self.backend.playback.use_fake_sink() + + def tearDown(self): + super(LocalPlaybackControllerTest, self).tearDown() + settings.BACKENDS = settings.original_backends + + def add_track(self, path): + uri = path_to_uri(data_folder(path)) + track = Track(uri=uri, length=4464) + self.backend.current_playlist.add(track) + + def test_uri_handler(self): + self.assert_('file://' in self.backend.uri_handlers) + + def test_play_mp3(self): + self.add_track('blank.mp3') + self.playback.play() + self.assertEqual(self.playback.state, self.playback.PLAYING) + + def test_play_ogg(self): + self.add_track('blank.ogg') + self.playback.play() + self.assertEqual(self.playback.state, self.playback.PLAYING) + + def test_play_flac(self): + self.add_track('blank.flac') + self.playback.play() + self.assertEqual(self.playback.state, self.playback.PLAYING) diff --git a/tests/backends/local/backend_test.py b/tests/backends/local/stored_playlists_test.py similarity index 50% rename from tests/backends/local/backend_test.py rename to tests/backends/local/stored_playlists_test.py index a59c8420..bb03f997 100644 --- a/tests/backends/local/backend_test.py +++ b/tests/backends/local/stored_playlists_test.py @@ -1,10 +1,11 @@ import unittest import os +from tests import SkipTest + # FIXME Our Windows build server does not support GStreamer yet import sys if sys.platform == 'win32': - from tests import SkipTest raise SkipTest from mopidy import settings @@ -13,71 +14,10 @@ from mopidy.mixers.dummy import DummyMixer from mopidy.models import Playlist, Track from mopidy.utils.path import path_to_uri -from tests.backends.base.backend import * -from tests import SkipTest, data_folder - -song = data_folder('song%s.wav') -generate_song = lambda i: path_to_uri(song % i) - -# FIXME can be switched to generic test -class LocalCurrentPlaylistControllerTest(BaseCurrentPlaylistControllerTest, - unittest.TestCase): - tracks = [Track(uri=generate_song(i), length=4464) - for i in range(1, 4)] - - backend_class = LocalBackend - - def setUp(self): - self.original_backends = settings.BACKENDS - settings.BACKENDS = ('mopidy.backends.local.LocalBackend',) - super(LocalCurrentPlaylistControllerTest, self).setUp() - - def tearDown(self): - super(LocalCurrentPlaylistControllerTest, self).tearDown() - settings.BACKENDS = settings.original_backends - - -class LocalPlaybackControllerTest(BasePlaybackControllerTest, - unittest.TestCase): - tracks = [Track(uri=generate_song(i), length=4464) - for i in range(1, 4)] - backend_class = LocalBackend - - def setUp(self): - self.original_backends = settings.BACKENDS - settings.BACKENDS = ('mopidy.backends.local.LocalBackend',) - - super(LocalPlaybackControllerTest, self).setUp() - # Two tests does not work at all when using the fake sink - #self.backend.playback.use_fake_sink() - - def tearDown(self): - super(LocalPlaybackControllerTest, self).tearDown() - settings.BACKENDS = settings.original_backends - - def add_track(self, path): - uri = path_to_uri(data_folder(path)) - track = Track(uri=uri, length=4464) - self.backend.current_playlist.add(track) - - def test_uri_handler(self): - self.assert_('file://' in self.backend.uri_handlers) - - def test_play_mp3(self): - self.add_track('blank.mp3') - self.playback.play() - self.assertEqual(self.playback.state, self.playback.PLAYING) - - def test_play_ogg(self): - self.add_track('blank.ogg') - self.playback.play() - self.assertEqual(self.playback.state, self.playback.PLAYING) - - def test_play_flac(self): - self.add_track('blank.flac') - self.playback.play() - self.assertEqual(self.playback.state, self.playback.PLAYING) - +from tests import data_folder +from tests.backends.base.stored_playlists import \ + BaseStoredPlaylistsControllerTest +from tests.backends.local import generate_song class LocalStoredPlaylistsControllerTest(BaseStoredPlaylistsControllerTest, unittest.TestCase): @@ -149,27 +89,3 @@ class LocalStoredPlaylistsControllerTest(BaseStoredPlaylistsControllerTest, def test_save_sets_playlist_uri(self): raise SkipTest - - -class LocalLibraryControllerTest(BaseLibraryControllerTest, - unittest.TestCase): - - backend_class = LocalBackend - - def setUp(self): - self.original_tag_cache = settings.LOCAL_TAG_CACHE - self.original_music_folder = settings.LOCAL_MUSIC_FOLDER - - settings.LOCAL_TAG_CACHE = data_folder('library_tag_cache') - settings.LOCAL_MUSIC_FOLDER = data_folder('') - - super(LocalLibraryControllerTest, self).setUp() - - def tearDown(self): - settings.LOCAL_TAG_CACHE = self.original_tag_cache - settings.LOCAL_MUSIC_FOLDER = self.original_music_folder - - super(LocalLibraryControllerTest, self).tearDown() - -if __name__ == '__main__': - unittest.main()