def test_get_playlists(self):
self.shell.props.playlist_manager.get_playlists.return_value = [
PlaylistStub("my_source", entries=[EntryStub(1)])
]
rb = RBHandler(self.shell)
playlists = rb.get_playlists()
self.assertEquals(len(playlists), 1)
def test_playing_entry(self):
rbplayer = RBHandler(self.shell)
self.player.get_playing_entry.return_value = None
self.assertIsNone(rbplayer.get_playing_entry())
entry = Mock()
entry.get_ulong.return_value = 1
self.player.get_playing_entry.return_value = entry
self.assertEquals(int(rbplayer.get_playing_entry()), 1)
def test_get_source_entries(self):
rb = RBHandler(self.shell)
source = SourceStub()
source.query_model = ModelStub(EntryStub(1), EntryStub(2), EntryStub(3))
rb.load_source_entries(source)
entries = source.entries
entries = [entry.id for entry in entries]
self.assertListEqual(entries, [1, 2, 3])
def test_play_entry_with_valid_id_works(self):
entry = Mock()
source = Mock()
self.player.props.queue_source = source
self.player.get_playing.return_value = (None, True)
self.db.entry_lookup_by_id.return_value = entry
rbplayer = RBHandler(self.shell)
rbplayer.play_entry(1)
self.player.play_entry.assert_called_with(entry, source)
def test_query_genre_works(self, ptr_array, query_model):
item = Mock()
array, model = Mock(), ModelStub(item)
query_model.return_value = model
ptr_array.return_value = array
rb = RBHandler(self.shell)
rb.query({"genre": "a nice genre"})
self.db.do_full_query_parsed.assert_called_with(model, array)
self.db.query_append_params.assert_has_calls([call(array, "FUZZY", "GENRE_FOLDED", "a nice genre")])
def test_query_artist_works(self, ptr_array, query_model):
item = Mock()
array, model = Mock(), ModelStub(item)
query_model.return_value = model
ptr_array.return_value = array
rb = RBHandler(self.shell)
rb.query({"artist": "calabazas"})
self.db.do_full_query_parsed.assert_called_with(model, array)
self.db.query_append_params.assert_has_calls([call(array, "FUZZY", "ARTIST_FOLDED", "calabazas")])
def test_query_with_rating_exact_match_and_play_count(self, ptr_array, query_model):
item = Mock()
array, model = Mock(), ModelStub(item)
query_model.return_value = model
ptr_array.return_value = array
rb = RBHandler(self.shell)
rb.query({"rating": 5, "play_count": 2, "exact-match": True, "first": 3, "limit": 1})
self.assertEquals(model.sort_order, "album_sort_func")
self.assertFalse(model.desc)
self.db.do_full_query_parsed.assert_called_with(model, array)
self.db.query_append_params.assert_has_calls(
[
call(array, "EQUALS", "TYPE", "song"),
call(array, "GREATER_THAN", "rating", 5.0),
call(array, "GREATER_THAN", "play_count", 2),
]
)
def test_query_for_all_works(self, ptr_array, query_model):
item = Mock()
array, model = Mock(), ModelStub(item)
query_model.return_value = model
ptr_array.return_value = array
rb = RBHandler(self.shell)
rb.query({"all": "calabazas"})
self.db.do_full_query_parsed.assert_called_with(model, array)
self.db.query_append_params.assert_has_calls(
[
call(array, "EQUALS", "TYPE", "song"),
call(array, "FUZZY", "ARTIST_FOLDED", "calabazas"),
call(array, "EQUALS", "TYPE", "song"),
call(array, "FUZZY", "TITLE_FOLDED", "calabazas"),
call(array, "EQUALS", "TYPE", "song"),
call(array, "FUZZY", "ALBUM_FOLDED", "calabazas"),
call(array, "EQUALS", "TYPE", "song"),
call(array, "FUZZY", "GENRE_FOLDED", "calabazas"),
]
)
def test_query_with_invalid_type_fails(self, ptr_array, query_model):
rb = RBHandler(self.shell)
with self.assertRaises(InvalidQueryException):
rb.query({"type": "x"})
def test_seek(self):
rbplayer = RBHandler(self.shell)
rbplayer.seek(15)
self.player.seek.assert_called_with(15)
def test_get_source_with_index_returns_none(self):
rb = RBHandler(self.shell)
source = rb.get_source(1)
self.assertIsNone(source)
def test_get_playing_time_string_calls_player(self):
self.player.get_playing_time_string.return_value = "bla"
rbplayer = RBHandler(self.shell)
self.assertEquals(rbplayer.get_playing_time_string(), "bla")
def test_play_previous_works(self):
self.player.get_playing.return_value = (None, True)
rbplayer = RBHandler(self.shell)
rbplayer.previous()
self.player.do_previous.assert_called_with()
def test_toggle_shuffle(self):
rbplayer = RBHandler(self.shell)
rbplayer.set_play_order(ORDER_LINEAR)
rbplayer.toggle_shuffle()
self.assertEquals(rbplayer.get_play_order(), ORDER_SHUFFLE)
def test_get_playing_time_calls_player(self):
self.player.get_playing_time.return_value = (None, 10)
rbplayer = RBHandler(self.shell)
self.assertEquals(rbplayer.get_playing_time(), 10)
def test_play_entry_with_invalid_id_fails(self):
rbplayer = RBHandler(self.shell)
with self.assertRaises(Exception):
rbplayer.play_entry("invalid")
def test_set_volume_calls_player(self):
rbplayer = RBHandler(self.shell)
rbplayer.set_volume(2.0)
self.player.set_volume.assert_called_with(2.0)
def test_get_playlists_without_entries_works(self):
self.shell.props.playlist_manager.get_playlists.return_value = [PlaylistStub("my_source")]
rb = RBHandler(self.shell)
playlists = rb.get_playlists()
playlist = get_playlist(playlists[0])
self.assertEquals(playlist["entries"], [])
def test_set_rating_with_invalid_value_fails(self):
rbplayer = RBHandler(self.shell)
with self.assertRaises(Exception):
rbplayer.set_rating(1, 'x')
def test_get_mute(self):
rbplayer = RBHandler(self.shell)
self.player.get_mute.return_value = (None, True)
self.assertTrue(rbplayer.get_mute())
self.player.get_mute.return_value = (None, False)
self.assertFalse(rbplayer.get_mute())
def test_playing_status(self):
rbplayer = RBHandler(self.shell)
self.player.get_playing.return_value = (None, True)
self.assertTrue(rbplayer.get_playing_status())
self.player.get_playing.return_value = (None, False)
self.assertFalse(rbplayer.get_playing_status())
def test_toggle_loop(self):
rbplayer = RBHandler(self.shell)
rbplayer.set_play_order(ORDER_SHUFFLE)
rbplayer.toggle_loop()
self.assertEquals(rbplayer.get_play_order(), "shuffle-loop")
def test_play_source(self):
self.player.get_playing.return_value = (None, True)
rb = RBHandler(self.shell)
source = Mock(source=SourceStub())
self.assertTrue(rb.play_source(source))
self.shell.props.shell_player.set_playing_source.assert_called_with(source.source)
def test_play_pause(self):
self.player.get_playing.return_value = (None, True)
self.player.playpause.return_value = 1
rbplayer = RBHandler(self.shell)
self.assertEquals(rbplayer.play_pause(), 1)
self.player.playpause.assert_called_with(False)
def test_toggle_mute(self):
self.player.get_mute.return_value = (None, False)
rbplayer = RBHandler(self.shell)
rbplayer.toggle_mute()
self.player.set_mute.assert_called_with(True)
def test_play_entry_with_none_as_id_fails(self):
rbplayer = RBHandler(self.shell)
with self.assertRaises(Exception):
rbplayer.play_entry(None)
def test_set_rating_works(self):
rbplayer = RBHandler(self.shell)
self.db.entry_lookup_by_id.side_effect = lambda x: x
rbplayer.set_rating(1, 5)
self.db.entry_set.assert_called_with(1, 'rating', 5)
def test_get_volume(self):
rbplayer = RBHandler(self.shell)
self.player.get_volume.return_value = (None, 1.0)
self.assertEquals(rbplayer.get_volume(), 1.0)
self.player.get_volume.return_value = (None, 0.5)
self.assertEquals(rbplayer.get_volume(), 0.5)
def test_get_entry_works(self):
rbplayer = RBHandler(self.shell)
entry = rbplayer.get_entry(1)
self.assertEquals(entry.id, 1)
def test_set_volume_with_invalid_value_fails(self):
rbplayer = RBHandler(self.shell)
with self.assertRaises(Exception):
rbplayer.set_volume("myvolume")
