def test_two_oracles(self): songs = ["1", "2", "3", "4", "5", "6"] p1 = oracles.PlaylistOracle(songs[:2]) p2 = oracles.PlaylistOracle(songs[2:]) o = oracles.ChainOracle() o.add(p1) o.add(p2) self.assertListEqual(collect(o), songs)
def test_interrupt_after_finish(self): songs1 = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs1) songs2 = ["4", "5", "6"] p2 = oracles.PlaylistOracle(songs2) o = oracles.InterruptOracle(p1) collected = collect(o) o.interrupt(p2) collected.extend(collect(p2)) self.assertListEqual(collected, songs1 + songs2)
def test_interrupt_before_finish(self): songs1 = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs1) songs2 = ["4", "5", "6"] p2 = oracles.PlaylistOracle(songs2) o = oracles.InterruptOracle(p1) collected = [o.current_song(), o.next_song()] o.interrupt(p2) collected.extend(collect(o)) self.assertListEqual(collected, ["1", "2", "2", "4", "5", "6", "3"])
def test_add_empties(self): songs = ["1", "2", "3"] o = oracles.ChainOracle() o.add(None) memoized_none_song = o.current_song() o.add(oracles.PlaylistOracle([])) o.add(oracles.PlaylistOracle(songs)) self.assertIsNone(memoized_none_song) self.assertIsNone(o.current_song()) # Chop off the "None" from the start because of the first "current_song" call. self.assertListEqual(collect(o)[1:], songs)
def test_add_halfway_through(self): songs1 = ["1", "2", "3", "4"] p1 = oracles.PlaylistOracle(songs1) songs2 = ["5", "6", "7"] p2 = oracles.PlaylistOracle(songs2) o = oracles.ChainOracle() o.add(p1) collected = [o.current_song(), o.next_song()] o.add(p2) # Shave the first entry off "collect" since we already got it. collected.extend(collect(o)[1:]) self.assertListEqual(collected, songs1 + songs2)
def test_memoize_old_oracles_after_switching(self): songs1 = ["1"] p1 = oracles.PlaylistOracle(songs1) songs2 = ["2"] p2 = oracles.PlaylistOracle(songs2) o = oracles.SwitchOracle() o.set_oracle(p1) first_song_on_p1_rv = o.current_song() o.set_oracle(p2) memoized_first_song_from_p1_rv = o.current_song() new_first_song_from_p2_rv = o.next_song() self.assertEqual(first_song_on_p1_rv, "1") self.assertEqual(memoized_first_song_from_p1_rv, "1") self.assertEqual(new_first_song_from_p2_rv, "2")
def test_empty_oracles_before_valid_oracles_get_ignored(self): songs1 = ["1", "2", "3"] co = oracles.ChainOracle() co.add(oracles.PlaylistOracle([])) co.add(oracles.PlaylistOracle([])) so = oracles.SwitchOracle() co.add(so) co.add(oracles.PlaylistOracle(songs1)) songs2 = ["4", "5", "6"] collected1 = collect(co) so.set_oracle(oracles.PlaylistOracle(songs2)) collected2 = collect(co) self.assertListEqual(collected1, ["1", "2", "3"]) self.assertListEqual(collected2, [None])
def test_empty_start(self): songs = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs) p2 = oracles.PlaylistOracle(songs) o = oracles.ChainOracle() song0 = o.current_song() song1 = o.next_song() o.add(p1) o.add(p2) collected = collect(o) self.assertIsNone(song0) self.assertIsNone(song1) # Chop off the memoized "None" at the beginning. self.assertListEqual(collected[1:], songs * 2)
def test_immediate_next_song_returns_second_normally(self): songs = ["1", "2"] p = oracles.PlaylistOracle(songs) o = oracles.ChainOracle() o.add(p) self.assertEqual(o.next_song(), "2")
def test_go_to_second_song_without_memoizing_call_to_current_song(self): songs = ["1", "2"] p = oracles.PlaylistOracle(songs) o = oracles.SwitchOracle() o.set_oracle(p) self.assertEqual(o.next_song(), "2")
def queue(self, alias: str): """ Tacks a set of songs onto the end of the existing playlist chain. :param alias: :return: """ songs = self.media_library.get(alias) self.queueing_oracle.add(oracles.PlaylistOracle(songs))
def test_finish_list_then_continue(self): songs1 = ["1", "2", "3", "4"] songs2 = ["5", "4", "3", "2"] p1 = oracles.PlaylistOracle(songs1) p2 = oracles.PlaylistOracle(songs2) o = oracles.ChainOracle() o.add(p1) collected1 = collect(o) o.add(p2) collected2 = collect(o) self.assertListEqual(collected1, songs1) # Chop off the memoized None at the beginning. self.assertListEqual(collected2[1:], songs2)
def test_no_default_immediately_start(self): songs = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs) o = oracles.InterruptOracle(None) o.interrupt(p1) collected = collect(o) self.assertListEqual(collected, songs)
def test_none_after_finishing_chain_sticks(self): songs = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs) p2 = oracles.PlaylistOracle(songs) o = oracles.ChainOracle() o.add(p1) collected = collect(o) no_songs_available_rv = o.next_song() o.add(p2) memoized_to_none_rv = o.current_song() start_next_list_rv = o.next_song() self.assertEqual(collected, songs) self.assertIsNone(no_songs_available_rv) self.assertIsNone(memoized_to_none_rv) self.assertEqual(start_next_list_rv, "1")
def test_clear(self): songs1 = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs1) songs2 = ["4", "5", "6"] p2 = oracles.PlaylistOracle(songs2) # Add p1, only collect the first two, clear, # collect 2 of p2, then clear again and collect one last song. o = oracles.ChainOracle() o.add(p1) collected = [o.current_song(), o.next_song()] o.clear() o.add(p2) collected.extend([o.next_song(), o.next_song()]) o.clear() collected.append(o.next_song()) self.assertListEqual(collected, ["1", "2", "4", "5", None])
def test_formerly_empty_oracle_not_ignored_when_filled_before_memoization( self): """This tests what happens when you fill an oracle that used to return null before accessing it for the first time (in this case, so - which unlike the test above, gets filled with songs before we call co.current_song() in collect())""" songs1 = ["1", "2", "3"] co = oracles.ChainOracle() co.add(oracles.PlaylistOracle([])) co.add(oracles.PlaylistOracle([])) so = oracles.SwitchOracle() co.add(so) co.add(oracles.PlaylistOracle(songs1)) songs2 = ["4", "5", "6"] so.set_oracle(oracles.PlaylistOracle(songs2)) collected = collect(co) self.assertListEqual(collected, ["4", "5", "6", "1", "2", "3"])
def test_adding_after_memoizing_none_plays_first_song_after_adding_other_oracles( self): songs1 = ["1"] p1 = oracles.PlaylistOracle(songs1) songs2 = ["2"] p2 = oracles.PlaylistOracle(songs2) o = oracles.ChainOracle() o.add(p1) first_song_rv = o.current_song() off_the_end_rv = o.next_song() o.add(p2) memoized_off_the_end_rv = o.current_song() second_song_rv = o.next_song() self.assertEqual(first_song_rv, "1") self.assertIsNone(off_the_end_rv) self.assertIsNone(memoized_off_the_end_rv) self.assertEqual(second_song_rv, "2")
def test_memoizing_null(self): songs1 = ["1"] p1 = oracles.PlaylistOracle(songs1) o = oracles.SwitchOracle() o.set_oracle(None) none_song = o.current_song() o.set_oracle(p1) songs_collected = collect(o) self.assertIsNone(none_song) self.assertListEqual(songs_collected, [None, "1"])
def test_add_oracle(self): songs = ["1", "2", "3"] o = oracles.SwitchOracle() p1 = oracles.PlaylistOracle(songs) no_song_available_rv = o.current_song() o.set_oracle(p1) self.assertIsNone(no_song_available_rv) # Collect will return "None" first because we've memoized # "None" above, and collect calls "current_song()" first. self.assertListEqual(collect(o), [None, *songs])
def play(self, song_alias: str): """ Clear out all existing songs from the oracle list and play the new set of songs indicated by the alias. :param song_alias: Refers to an alias in the media library to interrupt literally everything and play now. """ songs = self.media_library.get(song_alias) self.queueing_oracle = oracles.ChainOracle() self.switch_oracle.set_oracle(self.queueing_oracle) self.queueing_oracle.add(oracles.PlaylistOracle(songs)) self.interrupt_oracle.clear_interrupt() self.vlc_player.next_song()
def test_set_to_none(self): songs = ["1", "2", "3"] o = oracles.SwitchOracle() p1 = oracles.PlaylistOracle(songs) # Only get 2 songs so that we can make sure the third *isn't* collected when we switch. o.set_oracle(p1) collected = [o.current_song(), o.next_song()] o.set_oracle(None) self.assertIsNone(o.next_song()) self.assertListEqual(collected, songs[:2])
def test_none_returning_current_song_sticks(self): songs = ["1", "2", "3"] p = oracles.PlaylistOracle(songs) o = oracles.ChainOracle() no_song_available_rv = o.current_song() o.add(p) memoized_to_none_rv = o.current_song() next_song_rv = o.next_song() self.assertIsNone(no_song_available_rv) self.assertIsNone(memoized_to_none_rv) self.assertEqual(next_song_rv, "1")
def test_no_default(self): songs = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs) o = oracles.InterruptOracle(None) collected = [o.current_song()] o.interrupt(p1) collected.extend(collect(o)) # Two "None"s, one from the initial "current_song", one from the "current_song" in collect() expected = list([None, None]) expected.extend(songs) self.assertListEqual(collected, expected)
def test_clearing_oracles_memoizes_last_song(self): songs1 = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs1) songs2 = ["4", "5"] p2 = oracles.PlaylistOracle(songs2) o = oracles.ChainOracle() o.add(p1) first_song_rv = o.current_song() o.clear() memoized_first_song_rv = o.current_song() empty_next_song_rv = o.next_song() still_empty_current_song_rv = o.next_song() o.add(p2) # This should be the second song since "p" maintains its state even after being cleared. second_song_rv = o.next_song() self.assertEqual(first_song_rv, "1") self.assertEqual(memoized_first_song_rv, "1") self.assertIsNone(empty_next_song_rv) self.assertIsNone(still_empty_current_song_rv) self.assertEqual(second_song_rv, "4")
def test_set_to_another(self): o = oracles.SwitchOracle() songs1 = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs1) songs2 = ["4", "5", "6"] p2 = oracles.PlaylistOracle(songs2) songs3 = ["7", "8", "9"] p3 = oracles.PlaylistOracle(songs3) o.set_oracle(p1) collected = [o.current_song(), o.next_song()] o.set_oracle(p2) collected.extend( [o.next_song(), o.next_song(), o.next_song(), o.next_song()]) o.set_oracle(p3) collected.extend([o.next_song(), o.next_song(), o.next_song()]) self.assertListEqual( collected, list(itertools.chain(songs1[:2], songs2, [None], songs3)))
def test_memoize_to_none_and_play_first_with_current_song_before_setting( self): songs = ["1", "2"] p = oracles.PlaylistOracle(songs) o = oracles.SwitchOracle() no_songs_set_rv = o.current_song() o.set_oracle(p) memoized_to_none_rv = o.current_song() first_song_of_playlist_rv = o.next_song() self.assertIsNone(no_songs_set_rv) self.assertIsNone(memoized_to_none_rv) self.assertEqual(first_song_of_playlist_rv, "1")
def test_adding_after_memoizing_none_plays_first_song_before_adding_other_oracles( self): songs = ["1"] p = oracles.PlaylistOracle(songs) o = oracles.ChainOracle() memoizing_none_rv = o.current_song() o.add(p) still_memoized_none_rv = o.current_song() first_song_of_new_oracle_rv = o.next_song() self.assertIsNone(memoizing_none_rv) self.assertIsNone(still_memoized_none_rv) self.assertEqual(first_song_of_new_oracle_rv, "1")
def test_abuse(self): o = oracles.PlaylistOracle(["1"]) self.assertEqual(o.current_song(), "1") for _ in range(0, 5000): self.assertIsNone(o.next_song())
def test_empty_list(self): self.assertIsNone(oracles.PlaylistOracle(None).current_song()) self.assertIsNone(oracles.PlaylistOracle(None).next_song()) self.assertIsNone(oracles.PlaylistOracle([]).current_song()) self.assertIsNone(oracles.PlaylistOracle([]).next_song())
def test_default_behavior(self): songs = ["1", "2", "3"] p1 = oracles.PlaylistOracle(songs) o = oracles.InterruptOracle(p1) self.assertListEqual(collect(o), songs)