def setUp(self): settings.LOCAL_PLAYLIST_PATH = tempfile.mkdtemp() settings.LOCAL_TAG_CACHE_FILE = path_to_data_dir('library_tag_cache') settings.LOCAL_MUSIC_PATH = path_to_data_dir('') self.backend = self.backend_class() self.stored = self.backend.stored_playlists
def test_log_file_that_gst_thinks_is_mpeg_1_is_ignored(self): self.scan([path_to_data_dir('scanner/example.log')]) self.check_if_missing_plugin() log = path_to_data_dir('scanner/example.log') self.assertLess(self.result[log].duration, 100)
def test_cache_with_blank_track_info(self): tracks = parse_mpd_tag_cache(path_to_data_dir('blank_tag_cache'), path_to_data_dir('')) expected = Track(uri='local:track:song1.mp3', length=4000, last_modified=1272319626) self.assertEqual(set([expected]), tracks)
class LocalPlaybackControllerTest(PlaybackControllerTest, unittest.TestCase): backend_class = actor.LocalBackend config = { 'local': { 'media_dir': path_to_data_dir(''), 'playlists_dir': b'', 'tag_cache_file': path_to_data_dir('empty_tag_cache'), } } tracks = [Track(uri=generate_song(i), length=4464) for i in range(1, 4)] def add_track(self, path): uri = path_to_uri(path_to_data_dir(path)) track = Track(uri=uri, length=4464) self.tracklist.add([track]) def test_uri_scheme(self): self.assertIn('file', self.core.uri_schemes) def test_play_mp3(self): self.add_track('blank.mp3') self.playback.play() self.assertEqual(self.playback.state, PlaybackState.PLAYING) def test_play_ogg(self): self.add_track('blank.ogg') self.playback.play() self.assertEqual(self.playback.state, PlaybackState.PLAYING) def test_play_flac(self): self.add_track('blank.flac') self.playback.play() self.assertEqual(self.playback.state, PlaybackState.PLAYING)
def test_duration_is_set(self): self.scan(self.find('scanner/simple')) ogg = path_to_data_dir('scanner/simple/song1.ogg') mp3 = path_to_data_dir('scanner/simple/song1.mp3') self.assertEqual(self.result[mp3].duration, 4680) self.assertEqual(self.result[ogg].duration, 4680)
def test_duration_is_set(self): self.scan(self.find('scanner/simple')) self.assertEqual( self.durations[path_to_data_dir('scanner/simple/song1.mp3')], 4680) self.assertEqual( self.durations[path_to_data_dir('scanner/simple/song1.ogg')], 4680)
def test_simple_cache(self): tracks = parse_mpd_tag_cache(path_to_data_dir('simple_tag_cache'), path_to_data_dir('')) uri = path_to_uri(path_to_data_dir('song1.mp3')) track = Track(name='trackname', artists=expected_artists, track_no=1, album=expected_albums[0], length=4000, uri=uri) self.assertEqual(set([track]), tracks)
def test_albumartist_tag_cache(self): tracks = parse_mpd_tag_cache(path_to_data_dir("albumartist_tag_cache"), path_to_data_dir("")) uri = path_to_uri(path_to_data_dir("song1.mp3")) artist = Artist(name="albumartistname") album = expected_albums[0].copy(artists=[artist]) track = Track(name="trackname", artists=expected_artists, track_no=1, album=album, length=4000, uri=uri) self.assertEqual(track, list(tracks)[0])
def test_simple_cache(self): tracks = parse_mpd_tag_cache( path_to_data_dir('simple_tag_cache'), path_to_data_dir('')) track = Track( uri='local:track:song1.mp3', name='trackname', artists=expected_artists, track_no=1, album=expected_albums[0], date='2006', length=4000, last_modified=1272319626) self.assertEqual(set([track]), tracks)
def setUp(self): settings.LOCAL_PLAYLIST_PATH = tempfile.mkdtemp() settings.LOCAL_TAG_CACHE_FILE = path_to_data_dir('library_tag_cache') settings.LOCAL_MUSIC_PATH = path_to_data_dir('') self.audio = mock.Mock(spec=audio.Audio) self.backend = self.backend_class.start(audio=self.audio).proxy() self.core = core.Core(backends=[self.backend])
def test_uri_is_set(self): self.scan('scanner/simple') self.check( 'scanner/simple/song1.mp3', 'uri', 'file://%s' % path_to_data_dir('scanner/simple/song1.mp3')) self.check( 'scanner/simple/song1.ogg', 'uri', 'file://%s' % path_to_data_dir('scanner/simple/song1.ogg'))
def test_simple_cache(self): tracks = parse_mpd_tag_cache( path_to_data_dir('simple_tag_cache'), path_to_data_dir('')) uri = path_to_uri(path_to_data_dir('song1.mp3')) track = Track( uri=uri, name='trackname', artists=expected_artists, track_no=1, album=expected_albums[0], date='2006', length=4000) self.assertEqual(set([track]), tracks)
def test_find_exact_uri(self): track_1_uri = 'file://' + path_to_data_dir('uri1') result = self.library.find_exact(uri=track_1_uri) self.assertEqual(list(result[0].tracks), self.tracks[:1]) track_2_uri = 'file://' + path_to_data_dir('uri2') result = self.library.find_exact(uri=track_2_uri) self.assertEqual(list(result[0].tracks), self.tracks[1:2])
def test_uri_is_set(self): self.scan(self.find('scanner/simple')) self.check( 'scanner/simple/song1.mp3', 'uri', 'file://%s' % path_to_data_dir('scanner/simple/song1.mp3')) self.check( 'scanner/simple/song1.ogg', 'uri', 'file://%s' % path_to_data_dir('scanner/simple/song1.ogg'))
def setUp(self): settings.LOCAL_PLAYLIST_PATH = tempfile.mkdtemp() settings.LOCAL_TAG_CACHE_FILE = path_to_data_dir('library_tag_cache') settings.LOCAL_MUSIC_PATH = path_to_data_dir('') self.audio = audio.DummyAudio.start().proxy() self.backend = self.backend_class.start(audio=self.audio).proxy() self.core = core.Core(backends=[self.backend])
class LocalBackendEventsTest(events.BackendEventsTest, unittest.TestCase): backend_class = actor.LocalBackend config = { 'local': { 'media_dir': path_to_data_dir(''), 'playlists_dir': b'', 'tag_cache_file': path_to_data_dir('empty_tag_cache'), } }
def test_duration_is_set(self): self.scan(self.find("scanner/simple")) self.check_if_missing_plugin() ogg = path_to_data_dir("scanner/simple/song1.ogg") mp3 = path_to_data_dir("scanner/simple/song1.mp3") assert self.result[mp3].duration == 4680 assert self.result[ogg].duration == 4680
def test_unicode_cache(self): tracks = parse_mpd_tag_cache(path_to_data_dir("utf8_tag_cache"), path_to_data_dir("")) uri = path_to_uri(path_to_data_dir("song1.mp3")) artists = [Artist(name=u"æøå")] album = Album(name=u"æøå", artists=artists) track = Track(uri=uri, name=u"æøå", artists=artists, album=album, length=4000) self.assertEqual(track, list(tracks)[0])
class LocalLibraryControllerTest(LibraryControllerTest, unittest.TestCase): backend_class = actor.LocalBackend config = { 'local': { 'media_dir': path_to_data_dir(''), 'playlists_dir': b'', 'tag_cache_file': path_to_data_dir('library_tag_cache'), } }
def test_albumartist_tag_cache(self): tracks = parse_mpd_tag_cache( path_to_data_dir('albumartist_tag_cache'), path_to_data_dir('')) uri = path_to_uri(path_to_data_dir('song1.mp3')) artist = Artist(name='albumartistname') album = expected_albums[0].copy(artists=[artist]) track = Track( uri=uri, name='trackname', artists=expected_artists, track_no=1, album=album, date='2006', length=4000) self.assertEqual(track, list(tracks)[0])
def test_albumartist_tag_cache(self): tracks = parse_mpd_tag_cache( path_to_data_dir('albumartist_tag_cache'), path_to_data_dir('')) artist = Artist(name='albumartistname') album = expected_albums[0].copy(artists=[artist]) track = Track( uri='local:track:song1.mp3', name='trackname', artists=expected_artists, track_no=1, album=album, date='2006', length=4000, last_modified=1272319626) self.assertEqual(track, list(tracks)[0])
class LocalTracklistControllerTest(TracklistControllerTest, unittest.TestCase): backend_class = actor.LocalBackend config = { 'local': { 'media_dir': path_to_data_dir(''), 'playlists_dir': b'', 'tag_cache_file': path_to_data_dir('empty_tag_cache'), } } tracks = [Track(uri=generate_song(i), length=4464) for i in range(1, 4)]
def test_unicode_cache(self): tracks = parse_mpd_tag_cache( path_to_data_dir('utf8_tag_cache'), path_to_data_dir('')) uri = path_to_uri(path_to_data_dir('song1.mp3')) artists = [Artist(name='æøå')] album = Album(name='æøå', artists=artists) track = Track( uri=uri, name='æøå', artists=artists, album=album, length=4000) self.assertEqual(track, list(tracks)[0])
def test_unicode_cache(self): tracks = parse_mpd_tag_cache( path_to_data_dir('utf8_tag_cache'), path_to_data_dir('')) artists = [Artist(name='æøå')] album = Album(name='æøå', artists=artists) track = Track( uri='local:track:song1.mp3', name='æøå', artists=artists, album=album, length=4000, last_modified=1272319626) self.assertEqual(track, list(tracks)[0])
def test_unicode_cache(self): tracks = parse_mpd_tag_cache( path_to_data_dir('utf8_tag_cache'), path_to_data_dir('')) artists = [Artist(name='æøå')] album = Album(name='æøå', artists=artists) track = Track( uri='local:track:song1.mp3', name='æøå', artists=artists, composers=artists, performers=artists, genre='æøå', album=album, length=4000, last_modified=1272319626, comment='æøå&^`ൂ㔶') self.assertEqual(track, list(tracks)[0])
def test_musicbrainz_tagcache(self): tracks = parse_mpd_tag_cache(path_to_data_dir('musicbrainz_tag_cache'), path_to_data_dir('')) artist = list(expected_tracks[0].artists)[0].copy( musicbrainz_id='7364dea6-ca9a-48e3-be01-b44ad0d19897') albumartist = list(expected_tracks[0].artists)[0].copy( name='albumartistname', musicbrainz_id='7364dea6-ca9a-48e3-be01-b44ad0d19897') album = expected_tracks[0].album.copy(artists=[albumartist], musicbrainz_id='cb5f1603-d314-4c9c-91e5-e295cfb125d2') track = expected_tracks[0].copy(artists=[artist], album=album, musicbrainz_id='90488461-8c1f-4a4e-826b-4c6dc70801f0') self.assertEqual(track, list(tracks)[0])
class JsonLibraryTest(unittest.TestCase): config = { 'core': { 'data_dir': path_to_data_dir(''), }, 'local': { 'media_dir': path_to_data_dir(''), 'library': 'json', }, } def setUp(self): # noqa: N802 self.library = json.JsonLibrary(self.config) def _create_tracks(self, count): for i in range(count): self.library.add(Track(uri='local:track:%d' % i)) def test_search_should_default_limit_results(self): self._create_tracks(101) result = self.library.search() result_exact = self.library.search(exact=True) self.assertEqual(len(result.tracks), 100) self.assertEqual(len(result_exact.tracks), 100) def test_search_should_limit_results(self): self._create_tracks(100) result = self.library.search(limit=35) result_exact = self.library.search(exact=True, limit=35) self.assertEqual(len(result.tracks), 35) self.assertEqual(len(result_exact.tracks), 35) def test_search_should_offset_results(self): self._create_tracks(200) expected = self.library.search(limit=110).tracks[10:] expected_exact = self.library.search(exact=True, limit=110).tracks[10:] result = self.library.search(offset=10).tracks result_exact = self.library.search(offset=10, exact=True).tracks self.assertEqual(expected, result) self.assertEqual(expected_exact, result_exact)
def test_musicbrainz_tagcache(self): tracks = parse_mpd_tag_cache( path_to_data_dir('musicbrainz_tag_cache'), path_to_data_dir('')) artist = list(expected_tracks[0].artists)[0].copy( musicbrainz_id='7364dea6-ca9a-48e3-be01-b44ad0d19897') albumartist = list(expected_tracks[0].artists)[0].copy( name='albumartistname', musicbrainz_id='7364dea6-ca9a-48e3-be01-b44ad0d19897') album = expected_tracks[0].album.copy( artists=[albumartist], musicbrainz_id='cb5f1603-d314-4c9c-91e5-e295cfb125d2') track = expected_tracks[0].copy( artists=[artist], album=album, musicbrainz_id='90488461-8c1f-4a4e-826b-4c6dc70801f0') self.assertEqual(track, list(tracks)[0])
def test_files(self): mtimes = self.find('find') expected_files = [ b'find/foo/bar/file', b'find/foo/file', b'find/baz/file' ] expected = {path_to_data_dir(p): any_int for p in expected_files} self.assertEqual(expected, mtimes)
def test_refresh_missing_uri(self): # Verifies that https://github.com/mopidy/mopidy/issues/500 # has been fixed. tmpdir = tempfile.mkdtemp() try: tmplib = os.path.join(tmpdir, 'library.json.gz') shutil.copy(path_to_data_dir('library.json.gz'), tmplib) config = {'local': self.config['local'].copy()} config['local']['data_dir'] = tmpdir backend = actor.LocalBackend(config=config, audio=None) # Sanity check that value is in the library result = backend.library.lookup(self.tracks[0].uri) self.assertEqual(result, self.tracks[0:1]) # Clear and refresh. open(tmplib, 'w').close() backend.library.refresh() # Now it should be gone. result = backend.library.lookup(self.tracks[0].uri) self.assertEqual(result, []) finally: shutil.rmtree(tmpdir)
def generate_track(path, ident): uri = path_to_uri(path_to_data_dir(path)) track = Track(name='trackname', artists=expected_artists, track_no=1, album=expected_albums[0], length=4000, uri=uri) expected_tracks.append(track)
def setUp(self): config = { 'audio': { 'mixer': 'fakemixer track_max_volume=65536', 'mixer_track': None, 'output': 'fakesink', } } self.song_uri = path_to_uri(path_to_data_dir('song1.wav')) self.audio = audio.Audio.start(config=config).proxy()
def scan(self, path): paths = path_lib.find_files(path_to_data_dir(path)) uris = (path_lib.path_to_uri(p) for p in paths) scanner = scan.Scanner() for uri in uris: key = uri[len('file://'):] try: self.data[key] = scanner.scan(uri) except exceptions.ScannerError as error: self.errors[key] = error
class BaseTest(unittest.TestCase): config = { 'audio': { 'buffer_time': None, 'mixer': 'fakemixer track_max_volume=65536', 'mixer_track': None, 'mixer_volume': None, 'output': 'testoutput', 'visualizer': None, } } uris = [ path.path_to_uri(path_to_data_dir('song1.wav')), path.path_to_uri(path_to_data_dir('song2.wav')) ] audio_class = audio.Audio def setUp(self): # noqa: N802 config = { 'audio': { 'buffer_time': None, 'mixer': 'foomixer', 'mixer_volume': None, 'output': 'testoutput', 'visualizer': None, }, 'proxy': { 'hostname': '', }, } self.song_uri = path.path_to_uri(path_to_data_dir('song1.wav')) self.audio = self.audio_class.start(config=config, mixer=None).proxy() def tearDown(self): # noqa pykka.ActorRegistry.stop_all() def possibly_trigger_fake_playback_error(self, uri): pass def possibly_trigger_fake_about_to_finish(self): pass
def config(): return { "proxy": {}, "file": { "show_dotfiles": False, "media_dirs": [str(path_to_data_dir(""))], "excluded_file_extensions": [], "follow_symlinks": False, "metadata_timeout": 1000, }, }
class BaseTest(unittest.TestCase): config = { "audio": { "buffer_time": None, "mixer": "fakemixer track_max_volume=65536", "mixer_track": None, "mixer_volume": None, "output": "testoutput", "visualizer": None, } } uris = [ path.path_to_uri(path_to_data_dir("song1.wav")), path.path_to_uri(path_to_data_dir("song2.wav")), ] audio_class = audio.Audio def setUp(self): # noqa: N802 config = { "audio": { "buffer_time": None, "mixer": "foomixer", "mixer_volume": None, "output": "testoutput", "visualizer": None, }, "proxy": {"hostname": ""}, } self.song_uri = path.path_to_uri(path_to_data_dir("song1.wav")) self.audio = self.audio_class.start(config=config, mixer=None).proxy() def tearDown(self): # noqa pykka.ActorRegistry.stop_all() def possibly_trigger_fake_playback_error(self, uri): pass def possibly_trigger_fake_about_to_finish(self): pass
def test_playlists_are_loaded_at_startup(self): track = Track(uri=path_to_uri(path_to_data_dir('uri2'))) playlist = Playlist(tracks=[track], name='test') self.stored.save(playlist) self.backend = self.backend_class() self.stored = self.backend.stored_playlists self.assert_(self.stored.playlists) self.assertEqual('test', self.stored.playlists[0].name) self.assertEqual(track.uri, self.stored.playlists[0].tracks[0].uri)
class LocalBackendEventsTest(unittest.TestCase): config = { 'local': { 'media_dir': path_to_data_dir(''), 'playlists_dir': b'', 'tag_cache_file': path_to_data_dir('empty_tag_cache'), } } def setUp(self): self.audio = audio.DummyAudio.start().proxy() self.backend = actor.LocalBackend.start(config=self.config, audio=self.audio).proxy() self.core = core.Core.start(backends=[self.backend]).proxy() def tearDown(self): pykka.ActorRegistry.stop_all() def test_playlists_refresh_sends_playlists_loaded_event(self, send): send.reset_mock() self.core.playlists.refresh().get() self.assertEqual(send.call_args[0][0], 'playlists_loaded')
def setUp(self): config = { 'audio': { 'mixer': 'foomixer', 'mixer_volume': None, 'output': 'fakesink', 'visualizer': None, }, 'proxy': { 'hostname': '', }, } self.song_uri = path_to_uri(path_to_data_dir('song1.wav')) self.audio = audio.Audio.start(config=config, mixer=None).proxy()
def setUp(self): # noqa: N802 config = { 'audio': { 'mixer': 'foomixer', 'mixer_volume': None, 'output': 'testoutput', 'visualizer': None, }, 'proxy': { 'hostname': '', }, } self.song_uri = path_to_uri(path_to_data_dir('song1.wav')) self.audio = self.audio_class.start(config=config, mixer=None).proxy()
def test_playlists_are_loaded_at_startup(self): playlist_path = os.path.join(self.playlists_dir, 'test.m3u') track = Track(uri=path_to_uri(path_to_data_dir('uri2'))) playlist = self.core.playlists.create('test') playlist = playlist.copy(tracks=[track]) playlist = self.core.playlists.save(playlist) backend = self.backend_class(config=self.config, audio=self.audio) self.assert_(backend.playlists.playlists) self.assertEqual( path_to_uri(playlist_path), backend.playlists.playlists[0].uri) self.assertEqual( playlist.name, backend.playlists.playlists[0].name) self.assertEqual( track.uri, backend.playlists.playlists[0].tracks[0].uri)
def find(self, value): return list(path.find_files(path_to_data_dir(value)))
def check(self, name, key, value): name = path_to_data_dir(name) self.assertEqual(self.data[name][key], value)
def scan(self, path): scanner = Scanner( path_to_data_dir(path), self.data_callback, self.error_callback) scanner.start()
def setUp(self): settings.MIXER = 'fakemixer track_max_volume=65536' settings.OUTPUT = 'fakesink' self.song_uri = path_to_uri(path_to_data_dir('song1.wav')) self.audio = audio.Audio.start().proxy()
def test_file(self): files = self.find('blank.mp3') self.assertEqual(len(files), 1) self.assert_(files[0], path_to_data_dir('blank.mp3'))
def test_lookup_respects_blacklist_globbing(backend, track_uri): blacklist = [path.path_to_uri(path_to_data_dir("")) + "*"] library = actor.StreamLibraryProvider(backend, blacklist) assert library.lookup(track_uri) == [Track(uri=track_uri)]
def track_uri(): return path.path_to_uri(path_to_data_dir("song1.wav"))
def test_empty_wav_file_is_ignored(self): self.scan([path_to_data_dir('scanner/empty.wav')]) self.assert_(self.errors)