def test_shows_add_to_queue_if_playing(self):
ps = self.get_playlist_selected()
self.navigator.player.is_playing.return_value = False
options = menus.Options(ps.get_options())
destinations = [value.destination for value in options.values()]
self.assertNotIn(ps.add_to_queue, destinations)
self.navigator.player.is_playing.return_value = True
options = menus.Options(ps.get_options())
destinations = [value.destination for value in options.values()]
self.assertIn(ps.add_to_queue, destinations)
def test_playlist_overview_shows_invalid_playlists_as_well(self):
self.playlists = [
utils.Playlist('', []),
utils.Playlist('A', [utils.Track('foo', ['bar'])]),
utils.Playlist('B', []),
utils.Playlist('C',
[utils.Track('foo', ['bar'], available=False)]),
utils.Playlist('D', []),
]
del self.playlists[1].link
class Session(object):
playlist_container = self.playlists
self.navigator.session = Session()
pov = menus.PlayListOverview(self.navigator)
pov.disable_loader()
pov.loader = MockLoader([[item, {}] for item in self.playlists])
options = menus.Options(pov.get_options())
self.assertEqual(len(options), 5)
all_playlist_options = [
t.destination.playlist for t in list(options.values())
]
for playlist in self.playlists:
self.assertIn(playlist, all_playlist_options)
def test_playlist_selected_contains_only_valid_tracks(self):
ps = self.get_playlist_selected()
options = menus.Options(ps.get_options())
self.assertIsNotNone(options.match_best_or_none('1'))
self.assertIsNotNone(options.match_best_or_none('2'))
self.assertIsNotNone(options.match_best_or_none('3'))
self.assertIsNone(options.match_best_or_none('4'))
def test_check_unique_keys(self):
with self.assertRaises(TypeError):
menus.Options({
'a': menus.MenuValue('p', Mock()),
' a': menus.MenuValue('k', Mock())
})
with self.assertRaises(TypeError):
self.op[' 1'] = menus.MenuValue('1', Mock())
def test_fuzzy_filter(self):
dct = {'1': menus.MenuValue('This is a playlist', Mock())}
op = menus.Options(dct)
should_match = (
'ThisIsAPlaylist',
'ThisPlaylist',
'tiaplay',
)
for _filter in should_match:
self.assertEqual(len(op.filter(_filter)), 1)
def test_possiblities_with_spaces(self):
op = menus.Options({
' a': menus.MenuValue('p', Mock()),
'b ': menus.MenuValue('p', Mock()),
' c ': menus.MenuValue('p', Mock()),
})
for key in 'a', 'b', 'c':
tc = op.get_possibilities(key)
self.assertEqual(len(tc), 1)
self.assertNotEqual(tc, [key])
self.assertIn(key, tc[0])
def test_matches_by_correct_key(self):
op = menus.Options({
'k': menus.MenuValue('1', Mock()),
'kk': menus.MenuValue('2', Mock()),
'kkk': menus.MenuValue('3', Mock()),
})
best = op.match_best_or_none('k')
self.assertEqual(best.name, '1')
best = op.match_best_or_none('kk')
self.assertEqual(best.name, '2')
best = op.match_best_or_none('kkk')
self.assertEqual(best.name, '3')
def setUp(self):
self.dct = {
'1': menus.MenuValue('A', Mock()),
'2': menus.MenuValue('B', Mock()),
'3': menus.MenuValue('C', Mock()),
's': menus.MenuValue('Search', Mock()),
'kk': menus.MenuValue('pp', Mock()),
'ko': menus.MenuValue('p', Mock()),
'q': menus.MenuValue('o', Mock()),
'o': menus.MenuValue('q', Mock()),
}
self.op = menus.Options(self.dct)
def test_matches_by_correct_padded_key(self):
op = menus.Options({
' a': menus.MenuValue('1', Mock()),
'b ': menus.MenuValue('2', Mock()),
' c ': menus.MenuValue('3', Mock()),
' s i ': menus.MenuValue('4', Mock()),
})
best = op.match_best_or_none('a')
self.assertEqual(best.name, '1')
best = op.match_best_or_none('b')
self.assertEqual(best.name, '2')
best = op.match_best_or_none('c')
self.assertEqual(best.name, '3')
best = op.match_best_or_none('si')
self.assertEqual(best.name, '4')
def test_shows_indicator_if_one_match(self):
self.submenu.filter = 'a'
self.submenu.get_options = Mock()
self.submenu.get_options.return_value = menus.Options({
'the_key':
menus.MenuValue('sindri', Mock()),
'foo':
menus.MenuValue('foo', Mock()),
'bar':
menus.MenuValue('bar', Mock()),
})
self.submenu.initialize()
ui = self.submenu.get_ui()
self.assertEqual(len([line for line in ui if 'sindri' in line]), 1)
self.submenu.filter = 'the_key'
ui = self.submenu.get_ui()
self.assertEqual(len([line for line in ui if 'sindri' in line]), 2)
def test_playlist_overview_shows_all_playlists(self):
self.playlists = [
utils.Playlist('A', [utils.Track('foo', ['bar'])]),
utils.Playlist('B', [utils.Track('foo', ['bar'])]),
utils.Playlist('C', [utils.Track('foo', ['bar'])]),
]
class Session(object):
playlist_container = self.playlists
self.navigator.session = Session()
pov = menus.PlayListOverview(self.navigator)
options = menus.Options(pov.get_options())
self.assertTrue(
all(
isinstance(value.destination, menus.PlayListSelected)
for value in options.values()))
for playlist in self.playlists:
self.assertIsNotNone(options.match_best_or_none(playlist.name))
def test_playlist_overview_does_not_show_invalid_playlists(self):
self.playlists = [
# This is the only one that should be shown
utils.Playlist('A', [utils.Track('foo', ['bar'])]),
utils.Playlist('B', []),
utils.Playlist('C',
[utils.Track('foo', ['bar'], available=False)]),
utils.Playlist('D', []),
utils.Playlist('', []),
]
del self.playlists[1].link
class Session(object):
playlist_container = self.playlists
self.navigator.session = Session()
pov = menus.PlayListOverview(self.navigator)
options = menus.Options(pov.get_options())
self.assertEqual(len(options), 1)
self.assertEqual(
list(options.values())[0].destination.playlist, self.playlists[0])
def test_shows_shuffle_play(self):
ps = self.get_playlist_selected()
options = menus.Options(ps.get_options())
destinations = [value.destination for value in options.values()]
self.assertIn(ps.shuffle_play, destinations)