Esempio n. 1
0
 def test_class_Playlist_method_remove_song(self):
     song2 = Song(artist="Metalica", album="metalica",
                  length=385, song_name="Nothing else matters")
     pl = Playlist("rado")
     pl.add_song(song2)
     pl.remove_song(song2)
     self.assertTrue(len(pl.song_lst) == 0)
Esempio n. 2
0
 def setUp(self):
     self.my_song = Song("Solder Of Frortune", "Deep Purple",
                         "Stormbringer", "3:14")
     self.second_song = Song("I Stand Alone", "Godsmack", "Awake", "4:30")
     self.rock = Playlist("Rock songs", True)
     self.songs = [self.my_song, self.second_song]
     self.rock.add_songs(self.songs)
 def test_add_list_of_songs_to_an_empty_playlist_then_return_the_total_length_of_the_songs(self):
     song = Song(title="Odin", artist="Manowar", album="The Sons of Odin", length="3:44")
     song2 = Song(title="Odin", artist="Manowar", album="The Sons of Odin", length="3:44")
     song3 = Song(title="Odin", artist="Manowar", album="The Sons of Odin", length="3:44")
     playlist = Playlist(name="Code", repeat=True, shuffle=True)
     playlist.add_songs([song, song2, song3])
     expected_result = '0:11:12'
     self.assertEqual(playlist.total_length(), expected_result)
 def test_the_function_artists_of_a_playlist_then_return_dictionary_where_keys_are_the_artists_and_values_are_the_numbers_of_the_songs(self):
     song = Song(title="Odin", artist="Manowar1", album="The Sons of Odin", length="3:44")
     song2 = Song(title="Odin", artist="Manowar2", album="The Sons of Odin", length="3:44")
     song3 = Song(title="Odin", artist="Manowar3", album="The Sons of Odin", length="3:44")
     playlist = Playlist(name="Code", repeat=True, shuffle=True)
     playlist.add_songs([song, song2, song3])
     expected_result = {'Manowar1': 1, 'Manowar2': 1, 'Manowar3': 1}
     self.assertEqual(playlist.artists(), expected_result)
 def test_returning_playlist_next_song_when_reach_the_last_song_and_shuffle_and_no_repeat_then_return_a_song(self):
     song = Song(title="Odin", artist="Manowar1", album="The Sons of Odin", length="3:44")
     song2 = Song(title="Odin", artist="Manowar2", album="The Sons of Odin", length="3:44")
     song3 = Song(title="Odin", artist="Manowar3", album="The Sons of Odin", length="3:44")
     playlist = Playlist(name="Code", repeat=False, shuffle=True)
     playlist.add_songs([song, song2, song3])
     expected_result = song
     self.assertEqual(type(playlist.next_song(song3)), type(expected_result))
 def setUp(self):
     self.pl = Playlist("ssss")
     self.pl.add_song(
         Song(title="Odin",
              artist="Manowar",
              album="The Sons of Odin",
              time="3:44"))
     self.pl.add_song(
         Song(title="Odin", artist="Manowar", album="Odin", time="6:26"))
Esempio n. 7
0
    def test_playlist_artists_works_as_expected(self):
        my_playlist = Playlist(name="Code", repeat=True, shuffle=True)
        test = Song(title="Odin",
                    artist="Manowar",
                    album="The Sons of Odin",
                    length="3:44")

        my_playlist.add_song(test)

        self.assertEqual(my_playlist.artists(), {'Manowar': 1})
 def test_next_songs_with_repeat_True(self):
     random_song = Song("Random", "Random", "The Sons of Odin", "3:44")
     another_song = Song("Anther", "Kanye West", "Heartless", "4:20")
     song = Song("Baby", "J.Beiber", "Gay Album", "3:50")
     p = Playlist("p", repeat=True)
     p.add_songs([self.song, random_song, another_song, song])
     self.assertEqual(p.next_song(), random_song)
     self.assertEqual(p.next_song(), another_song)
     self.assertEqual(p.next_song(), song)
     self.assertEqual(p.next_song(), self.song)
Esempio n. 9
0
    def test_playlist_add_song_adds_song_to_object_list_of_songs(self):
        test = Song(title="Odin",
                    artist="Manowar",
                    album="The Sons of Odin",
                    length="3:44")
        my_playlist = Playlist(name="Code", repeat=True, shuffle=True)

        my_playlist.add_song(test)

        assert test in my_playlist.songs
Esempio n. 10
0
    def test_class_Playlist_method_current_song(self):
        song2 = Song(artist="Metalica", album="metalica",
                     length=385, song_name="Nothing else matters")
        song3 = Song(
            artist="Metalica", album="metalica", length=385, song_name="The Unforgiven")
        song4 = Song(artist="Iron Maiden", album="Power Slave",
                     length=385, song_name="Fear of the dark")
        song5 = Song(
            artist="Iron Maiden", album="Power Slave", length=385, song_name="Acces High")
        song6 = Song(artist="Qvkata DLG", album="Човекът  който се смее",
                     length=385, song_name="Екстра а ти ?")

        songs = [song2, song3, song4, song5, song6]

        pl = Playlist("rado", repeat=True)
        pl.add_songs(songs)

        self.assertTrue(
            str(pl.next_song()) == "Metalica - The Unforgiven from metalica - 385")
        self.assertTrue(
            str(pl.next_song()) == "Iron Maiden - Fear of the dark from Power Slave - 385")
        self.assertTrue(
            str(pl.next_song()) == "Iron Maiden - Acces High from Power Slave - 385")

        pl2 = Playlist("rado2", shuffle=True)
        pl2.add_songs(songs)
Esempio n. 11
0
    def test_playlist_next_song_works_as_expected_with_no_repeat_and_no_shuffle(
            self):
        f = Song(title="Odin",
                 artist="Manowar",
                 album="The Sons of Odin",
                 length="3:44")
        s = Song(title="Empty",
                 artist="Metric",
                 album="Live It Out",
                 length="5:55")
        q = Song(title="Superman",
                 artist="Eminem",
                 album="The Eminem Show",
                 length="5:50")
        code_songs = Playlist(name="Code", repeat=False, shuffle=False)

        code_songs.add_song(f)
        code_songs.add_song(s)
        code_songs.add_song(q)

        code_songs.next_song()
        code_songs.next_song()

        self.assertEqual(code_songs.next_song(),
                         'There are no more songs in your playlist.')
Esempio n. 12
0
    def test_playlist_validate_name_raises_exception_if_name_not_str(self):
        test = 5
        exc = None

        try:
            Playlist.validate_name(test)
        except Exception as err:
            exc = err

        self.assertIsNotNone(exc)
        self.assertEqual(str(exc), 'Name must be of "str" type.')
Esempio n. 13
0
    def test_playlist_validate_shuffle_raises_exception_if_shuffle_not_bool(
            self):
        test = 5
        exc = None

        try:
            Playlist.validate_shuffle(test)
        except Exception as err:
            exc = err

        self.assertIsNotNone(exc)
        self.assertEqual(str(exc), 'Shuffle must be of "bool" type.')
Esempio n. 14
0
    def test_playlist_validate_name_raises_exception_if_name_is_empty_str(
            self):
        test = ''
        exc = None

        try:
            Playlist.validate_name(test)
        except Exception as err:
            exc = err

        self.assertIsNotNone(exc)
        self.assertEqual(str(exc), 'Empty string cannot be a name.')
Esempio n. 15
0
class testPlaylist(unittest.TestCase):
    def setUp(self):
        self.pl = Playlist("ssss")
        self.pl.add_song(
            Song(title="Odin",
                 artist="Manowar",
                 album="The Sons of Odin",
                 time="3:44"))
        self.pl.add_song(
            Song(title="Odin", artist="Manowar", album="Odin", time="6:26"))

    def test_next_song(self):
        self.assertEqual(self.pl.next_song(), "")
Esempio n. 16
0
    def test_playlist_remove_song_raises_exception_if_song_not_in_object_list_of_songs(
            self):
        test = Song(title="Odin",
                    artist="Manowar",
                    album="The Sons of Odin",
                    length="3:44")
        my_playlist = Playlist(name="Code", repeat=True, shuffle=True)
        exc = None

        try:
            my_playlist.remove_song(test)
        except Exception as err:
            exc = err

        self.assertIsNotNone(exc)
        self.assertEqual(str(exc), f'{test.title} is not in this playlist.')
Esempio n. 17
0
    def test_playlist_total_length_is_calculated_correctly_with_songs_under_a_minute(
            self):
        my_playlist = Playlist(name="Code", repeat=True, shuffle=True)
        test1 = Song(title="Odin",
                     artist="Manowar",
                     album="The Sons of Odin",
                     length="0:44")
        test2 = Song(title="Empty",
                     artist="Metric",
                     album="Live It Out",
                     length="0:10")

        my_playlist.add_song(test1)
        my_playlist.add_song(test2)

        self.assertEqual(my_playlist.total_length(), '0:54')
Esempio n. 18
0
    def test_class_Playlist_method_ppprint(self):
        song2 = Song(artist="Metalica", album="metalica",
                     length=385, song_name="Nothing else matters")
        song3 = Song(
            artist="Metalica", album="metalica", length=7200, song_name="The Unforgiven")
        song4 = Song(artist="Iron Maiden", album="Power Slave",
                     length=385, song_name="Fear of the dark")
        song5 = Song(
            artist="Iron Maiden", album="Power Slave", length=86400, song_name="Acces High")
        song6 = Song(artist="Qvkata DLG", album="Човекът  който се смее",
                     length=896385, song_name="Екстра а ти ?")
        songs = [song2, song3, song4, song5, song6]

        pl = Playlist("rado", shuffle=True)
        pl.add_songs(songs)
        pl.next_song()
Esempio n. 19
0
    def test_playlist_total_length_is_calculated_correctly_with_songs_sum_over_hour(
            self):
        my_playlist = Playlist(name="Code", repeat=True, shuffle=True)
        test1 = Song(title="Odin",
                     artist="Manowar",
                     album="The Sons of Odin",
                     length="55:44")
        test2 = Song(title="Empty",
                     artist="Metric",
                     album="Live It Out",
                     length="5:16")

        my_playlist.add_song(test1)
        my_playlist.add_song(test2)

        self.assertEqual(my_playlist.total_length(), '1:01:00')
    def test_save_load(self):
        song = Song("Baby", "J.Beiber", "Gay Album", "3:50")
        self.playlist.add_songs([self.song, song])
        self.playlist.save()

        g = Playlist.load("The-sex-and-the-city.json")
        self.assertEqual(self.playlist.songs, g.songs)
        self.assertEqual(g.name, "The sex and the city")
Esempio n. 21
0
class TestPlaylist(unittest.TestCase):

    def setUp(self):
        self.code_songs = Playlist(name="Code", repeat=True, shuffle=True)

    def test_initialisation(self):
        self.assertTrue(isinstance(self.code_songs, Playlist))

    def test_add_remove_song(self):
        a = Song()
        self.assertFalse(a in self.code_songs.song_list)
        self.code_songs.add_song(a)
        self.assertTrue(a in self.code_songs.song_list)
        self.code_songs.remove_song(a)
        self.assertTrue(a not in self.code_songs.song_list)

    def test_add_songs(self):
        a = Song()
        b = Song(title="Pesho's song", artist="Pesho",
                 album="Pesho/'s album", length="23:22:12")
        l = []
        l.append(a)
        l.append(b)
        self.code_songs.add_songs(l)
        self.assertTrue(a in self.code_songs.song_list)
        self.assertTrue(b in self.code_songs.song_list)

    def test_artists_histogram(self):
        a = Song(title="alaba", artist="Rihanna",
                 album="Nqkoi", length="12:02")
        b = Song(title="Pesho's song", artist="Pesho",
                 album="Pesho/'s album", length="23:22:12")
        c = Song(title="PeshosOtherSong", artist="Pesho",
                 album="blaa", length="22:12")
        self.code_songs.song_list.append(a)
        self.code_songs.song_list.append(b)
        self.code_songs.song_list.append(c)
        dicta = {}
        dicta['Pesho'] = 2
        dicta['Rihanna'] = 1
        self.assertEqual(dicta, self.code_songs.artists())

    def test_total_length(self):
        a = Song(title="alaba", artist="Rihanna",
                 album="Nqkoi", length="12:02")
        b = Song(title="Pesho's song", artist="Pesho",
                 album="Pesho/'s album", length="23:22:12")
        c = Song(title="PeshosOtherSong", artist="Pesho",
                 album="blaa", length="22:12")
        self.code_songs.song_list.append(a)
        self.code_songs.song_list.append(b)
        self.code_songs.song_list.append(c)
        self.assertEqual(self.code_songs.total_length(), '23:56:26')
 def setUp(self):
     self.title = "nana"
     self.artist = "Viki"
     self.album = "Na"
     self._length = "3:00"
     self.song = Song(self.title, self.artist, self.album, self._length)
     self.song2 = Song("lq", "Viktoria", "lqlq", "4:30")
     self.song3 = Song(self.title, self.artist, self.album, self._length)
     self.play_list = Playlist("random playlist")
     self.songs = [self.song, self.song2]
Esempio n. 23
0
    def test_class_Playlist_method_save_and_load(self):
        song2 = Song(artist="Metalica", album="metalica",
                     length=385, song_name="Nothing else matters")
        song3 = Song(
            artist="Metalica", album="metalica", length=7200, song_name="The Unforgiven")

        pl = Playlist("default")
        pl.add_song(song2)
        pl.add_song(song3)
        pl.save()
        pl.load()
Esempio n. 24
0
    def test_playlist_remove_song_removes_song_from_object_list_of_songs(self):
        test = Song(title="Odin",
                    artist="Manowar",
                    album="The Sons of Odin",
                    length="3:44")
        my_playlist = Playlist(name="Code", repeat=True, shuffle=True)

        my_playlist.add_song(test)
        my_playlist.remove_song(test)

        self.assertEqual(my_playlist.songs, [])
Esempio n. 25
0
    def test_class_Playlist_method_total_length(self):
        # 86400 seconds  =  1 day
        song2 = Song(artist="Metalica", album="metalica",
                     length=86400, song_name="Nothing else matters")
        song3 = Song(
            artist="Metalica", album="metalica", length=385, song_name="The Unforgiven")
        song4 = Song(artist="Iron Maiden", album="Power Slave",
                     length=385, song_name="Fear of the dark")
        song5 = Song(
            artist="Iron Maiden", album="Power Slave", length=385, song_name="Acces High")
        song6 = Song(artist="Qvkata DLG", album="Човекът  който се смее",
                     length=385, song_name="Екстра а ти ?")

        songs = [song2, song3, song4, song5, song6]

        pl = Playlist("rado")
        pl.add_songs(songs)
        self.assertTrue(str(pl.total_length()) == "1 day, 0:25:40")
        pl.remove_song(song2)
        self.assertTrue(str(pl.total_length()) == "0:25:40")
Esempio n. 26
0
    def test_class_Playlist_method_artist(self):
        song2 = Song(artist="Metalica", album="metalica",
                     length=385, song_name="Nothing else matters")
        song3 = Song(
            artist="Metalica", album="metalica", length=385, song_name="The Unforgiven")
        song4 = Song(artist="Iron Maiden", album="Power Slave",
                     length=385, song_name="Fear of the dark")
        song5 = Song(
            artist="Iron Maiden", album="Power Slave", length=385, song_name="Acces High")
        song6 = Song(artist="Qvkata DLG", album="Човека  който се смее",
                     length=385, song_name="Екстра а ти ?")

        songs = [song2, song3, song4, song5, song6]

        pl = Playlist("rado")
        pl.add_songs(songs)

        self.assertTrue(pl.artists()["Metalica"] == 2)
        self.assertTrue(pl.artists()["Iron Maiden"] == 2)
        self.assertTrue(pl.artists()["Qvkata DLG"] == 1)
Esempio n. 27
0
    def test_playlist_add_song_raises_excpetion_if_song_already_in_playlist(
            self):
        test1 = Song(title="Odin",
                     artist="Manowar",
                     album="The Sons of Odin",
                     length="3:44")
        test2 = Song(title="Odin",
                     artist="Manowar",
                     album="The Sons of Odin",
                     length="3:44")
        my_playlist = Playlist(name="Code", repeat=True, shuffle=True)
        exc = None

        my_playlist.add_song(test1)

        try:
            my_playlist.add_song(test2)
        except Exception as err:
            exc = err

        self.assertIsNotNone(exc)
        self.assertEqual(str(exc), 'Song is already in the playlist.')
Esempio n. 28
0
 def test_add_song_when_song_is_not_instance_of_class_song_then_raise_type_error(self):
     with self.assertRaises(TypeError):
         Playlist('OneRepublic').add_song(('Love Runs Out', 'OneRepublic', 'Native', '3:44'))
Esempio n. 29
0
    def test_playlist_validate_shuffle_passes_with_correct_input(self):
        test = True

        Playlist.validate_shuffle(test)
Esempio n. 30
0
class TestPlaylist(unittest.TestCase):
    """docstring for TestPlaylist"""
    def setUp(self):
        self.p = Playlist(name="Code", repeat=False, shuffle=False)
        self.song_1 = Song(title="Odin", artist="Manowar", album="The Sons of Odin", length="60")
        self.song_2 = Song(title="Odin2", artist="Manowar2", album="The Sons of Odin2", length="60")

    def test_Playlist_addsong(self):
        self.p.add_song(self.song_1)
        self.assertIn(self.song_1, self.p.playlist)

    def test_Playlist_addsongs(self):
        songs = [self.song_1, self.song_2]
        self.p.add_songs(songs)
        self.assertIn(self.song_1, self.p.playlist)
        self.assertIn(self.song_2, self.p.playlist)
        self.assertEqual(len(self.p.playlist), 2)

    def test_Playlist_remove_song(self):
        songs = [self.song_1, self.song_2]
        self.p.add_songs(songs)
        self.assertEqual(self.p.remove_song(self.song_1), self.song_1)
        self.assertEqual(len(self.p.playlist), 1)
    #tank_size - how much our car can ride with a full tank of gas. It is a positive integer in kilometers

    def test_Playlist_total_length(self):
        songs = [self.song_1, self.song_2]
        self.p.add_songs(songs)
        self.assertEqual(self.p.total_length(), "0:02:00")

    def test_Playlist_artists(self):
        songs = [self.song_1, self.song_2]
        self.p.add_songs(songs)
        self.p.add_song(self.song_1)

    def test_Playlist_shuffle(self):
        songs = [self.song_1, self.song_2]
        self.p.add_songs(songs)
        self.p._shuffle = True
        self.assertNotIn(self.p.shuffle(), self.p._shuffle_playlist)
        self.assertNotIn(self.p.shuffle(), self.p._shuffle_playlist)
        #self.assertEqual(self.p.shuffle(), 0)

    def test_Playlist_next_song(self):
        songs = [self.song_1, self.song_2]
        self.p.add_songs(songs)

    def test_Playlist_pprint_playlist(self):
        songs = [self.song_1, self.song_2]
        self.p.add_songs(songs)
        print(self.p.pprint_playlist())

    def test_Playlist_save(self):
        songs = [self.song_1, self.song_2]
        self.p.add_songs(songs)
        self.p.save('export.json')

    def test_Playlist_load(self):
        code = Playlist.load('export.json')
Esempio n. 31
0
 def test_Playlist_load(self):
     code = Playlist.load('export.json')
 def setUp(self):
     self.song = Song("Odin", "Manowar", "The Sons of Odin", "3:44")
     self.playlist = Playlist("The sex and the city")
Esempio n. 33
0
 def test_remove_song_when_song_is_present_in_songs_list_then_remove_song_from_playlist(self):
     test_playlist = Playlist('OneRepublic', songs_list=[Song(title='Love Runs Out', artist='OneRepublic', album='Native', length='3:44')])
     test_playlist.remove_song(Song(title='Love Runs Out', artist='OneRepublic', album='Native', length='3:44'))
     expected_result = []
     self.assertEqual(test_playlist.songs_list, expected_result)
 def setUp(self):
     self.s = Song("Odin", "Manowar", "The Sons of Odin", "3:44")
     self.other = Song("Odin", "Manowar", "The Sons of Odin", "3:44")
     self.other2 = Song("Odinkata", "Manowar", "The Sons of Odin", "3:4:40")
     self.my_playlist = Playlist("MyPlaylist", repeat=True, shuffle=False)
Esempio n. 35
0
    def test_playlist_validate_name_passes_with_correct_input(self):
        test = 'code'

        Playlist.validate_name(test)
Esempio n. 36
0
    def test_playlist_validate_repeat_passes_with_correct_input(self):
        test = True

        Playlist.validate_repeat(test)
Esempio n. 37
0
 def test_validation_when_song_in_songs_list_is_not_instance_of_class_song_then_raise_type_error(self):
     with self.assertRaises(TypeError):
         Playlist.validate_parameters('OneRepublic', songs_list=[('Love Runs Out', 'OneRepublic', 'Native', '3:44')])
Esempio n. 38
0
 def test_remove_song_when_song_is_not_instance_of_class_song_then_raise_type_error(self):
     test_playlist = Playlist('OneRepublic', songs_list=[Song(title='Love Runs Out', artist='OneRepublic', album='Native', length='3:44')])
     with self.assertRaises(TypeError):
         test_playlist.remove_song(('Love Runs Out', 'OneRepublic', 'Native', '3:44'))
Esempio n. 39
0
 def setUp(self):
     self.code_songs = Playlist(name="Code", repeat=True, shuffle=True)
Esempio n. 40
0
 def test_add_song_when_song_is_instance_of_class_song_then_add_song_to_playlist(self):
     test_playlist = Playlist('OneRepublic')
     test_playlist.add_song(Song(title='Love Runs Out', artist='OneRepublic', album='Native', length='3:44'))
     expected_result = [Song(title='Love Runs Out', artist='OneRepublic', album='Native', length='3:44')]
     self.assertEqual(test_playlist.songs_list, expected_result)
Esempio n. 41
0
 def setUp(self):
     self.p = Playlist(name="Code", repeat=False, shuffle=False)
     self.song_1 = Song(title="Odin", artist="Manowar", album="The Sons of Odin", length="60")
     self.song_2 = Song(title="Odin2", artist="Manowar2", album="The Sons of Odin2", length="60")
Esempio n. 42
0
    def test_playlist_total_length_is_calculated_correctly_without_any_songs(
            self):
        my_playlist = Playlist(name="Code", repeat=True, shuffle=True)

        self.assertEqual(my_playlist.total_length(), '0:00')
Esempio n. 43
0
 def test_remove_song_when_song_is_not_present_in_songs_list_then_raise_value_error(self):
     test_playlist = Playlist('OneRepublic', songs_list = [])
     with self.assertRaises(ValueError):
         test_playlist.remove_song(Song(title='Counting Stars', artist='OneRepublic', album='Native', length='3:50'))
Esempio n. 44
0
    def test_playlist_init_initializes_object_correctly(self):
        code_songs = Playlist(name="Code", repeat=True, shuffle=False)

        self.assertEqual(code_songs.name, 'Code')
        self.assertEqual(code_songs.repeat, True)
        self.assertEqual(code_songs.shuffle, False)
Esempio n. 45
0
class PlaylistTest(unittest.TestCase):
    def setUp(self):
        self.my_song = Song("Solder Of Frortune", "Deep Purple",
                            "Stormbringer", "3:14")
        self.second_song = Song("I Stand Alone", "Godsmack", "Awake", "4:30")
        self.rock = Playlist("Rock songs", True)
        self.songs = [self.my_song, self.second_song]
        self.rock.add_songs(self.songs)

    def test_playlist_constructor(self):
        self.assertTrue(isinstance(self.rock, Playlist))

    def test_add_song(self):
        self.assertEqual(self.rock.playlist, self.songs)

    def test_remove_song(self):
        self.rock.remove_song(self.my_song)
        self.assertEqual(self.rock.playlist, [self.second_song])

    def test_remove_song_fail(self):
        self.rock.remove_song(self.my_song)
        with self.assertRaises(NoSuchSong):
            self.rock.remove_song(self.my_song)

    def test_add_songs(self):
        self.assertEqual(self.rock.playlist, self.songs)

    def test_total_length(self):
        self.assertEqual(self.rock.total_length(), "0:07:44")

    def test_artists(self):
        histogram = {"Deep Purple": 1, "Godsmack": 1}
        self.assertEqual(self.rock.artists(), histogram)

    def test_repeat(self):
        self.assertEqual(self.rock.next_song(), self.my_song)
        self.assertEqual(self.rock.next_song(), self.second_song)
        self.assertEqual(self.rock.next_song(), self.my_song)

    def test_no_more_songs(self):
        self.rock.change_repeat(False)
        self.assertEqual(self.rock.next_song(), self.my_song)
        self.assertEqual(self.rock.next_song(), self.second_song)
        with self.assertRaises(NoMoreSongs):
            self.rock.next_song()
        self.rock.change_shuffle(True)
        self.rock.next_song()
        self.rock.next_song()
        with self.assertRaises(NoMoreSongs):
            self.rock.next_song()

    def test_shuffle(self):
        self.rock.change_shuffle(True)
        bard = Song("The Bard's Song", "Blind Guardian", "Somwhere Far Beyond",
                    "3:28")
        self.rock.add_song(bard)
        a = self.rock.next_song()
        b = self.rock.next_song()
        c = self.rock.next_song()
        self.assertTrue(a != b and c != a and c != b)
Esempio n. 46
0
    def test_playlist_next_song_works_as_expected_with_repeat_and_shuffle(
            self):
        f = Song(title="Odin",
                 artist="Manowar",
                 album="The Sons of Odin",
                 length="3:44")
        s = Song(title="Empty",
                 artist="Metric",
                 album="Live It Out",
                 length="5:55")
        q = Song(title="Superman",
                 artist="Eminem",
                 album="The Eminem Show",
                 length="5:50")
        code_songs = Playlist(name="Code", repeat=True, shuffle=True)
        test = Playlist(name="Code2", repeat=True, shuffle=True)

        code_songs.add_song(f)
        code_songs.add_song(s)
        code_songs.add_song(q)

        test.add_song(code_songs.next_song())
        test.add_song(code_songs.next_song())
        test.add_song(code_songs.next_song())

        code_songs.next_song()

        assert code_songs.next_song() in getattr(test, 'songs')
class TestPlaylist(unittest.TestCase):
    def setUp(self):
        self.title = "nana"
        self.artist = "Viki"
        self.album = "Na"
        self._length = "3:00"
        self.song = Song(self.title, self.artist, self.album, self._length)
        self.song2 = Song("lq", "Viktoria", "lqlq", "4:30")
        self.song3 = Song(self.title, self.artist, self.album, self._length)
        self.play_list = Playlist("random playlist")
        self.songs = [self.song, self.song2]

    def test_add_song(self):
        self.play_list.add_song(self.song)
        self.assertIn(self.song, self.play_list.get_song())

    def test_remove_song(self):
        self.play_list.remove_song(self.song)
        self.assertNotIn(self.song, self.play_list.get_song())

    def test_add_songs(self):
        self.play_list.add_songs(self.songs)
        self.assertIn(self.song, self.play_list.get_song())
        self.assertIn(self.song2, self.play_list.get_song())

    def test_total_length(self):
        pass

    def test_artist(self):
        pass

    def test_next_song(self):
        self.play_list.add_songs(self.songs)
        self.assertIn(self.play_list.next_song(), self.songs)

    def test_next_song_many_times(self):
        self.play_list.add_songs(self.songs)
        self.assertEqual(self.play_list.next_song, self.song)
        self.assertEqual(self.play_list.next_song, self.song2)

    def test_next_song_many_times_repeat_on(self):
        pass

    def test_next_song_suffle_on(self):
        self.play_list = Playlist("random playlist", repeat=True)

        self.play_list.add_songs(self.songs)
        self.assertEqual(self.play_list.next_song, self.song)
        self.assertEqual(self.play_list.next_song, self.song2)

    def test_json_dumps(self):
        pass

    if __name__ == "__main__":
        unittest.main()
class MusicPlayerTest(unittest.TestCase):

    def setUp(self):
        self.song = Song("Odin", "Manowar", "The Sons of Odin", "3:44")
        self.playlist = Playlist("The sex and the city")

    def test_str(self):
        self.assertEqual(str(
            self.song), "Manowar - Odin (The Sons of Odin) : 3:44")

    def test_adding_song_in_playlist(self):
        self.playlist.add_song(self.song)
        self.assertTrue(self.playlist.has_song(self.song))

    def test_removing_song(self):
        self.playlist.add_song(self.song)
        self.playlist.remove_song(self.song)
        self.assertFalse(self.playlist.has_song(self.song))

    def test_total_length(self):
        song = Song("Baby", "J.Beiber", "Gay Album", "3:50")
        self.playlist.add_songs([self.song, song])
        self.assertEqual(self.playlist.total_length(), "0:07:34")

    def test_artists(self):
        song = Song("Baby", "J.Beiber", "Gay Album", "3:50")
        self.playlist.add_songs([self.song, song])
        self.assertEqual(
            self.playlist.artists(), {'Manowar': 1, "J.Beiber": 1})

    def test_play_next_song_in_empty_playlist(self):
        with self.assertRaises(Exception):
            self.playlist.next_song()

    def test_play_next_song_if_there_is_only_one_with_repeat_False(self):
        self.playlist.add_song(self.song)
        with self.assertRaises(Exception):
            self.playlist.next_song()

    def test_next_songs_with_repeat_False(self):
        random_song = Song("Random", "Manowar", "The Sons of Odin", "1:30:44")
        another_song = Song("Anther", "Manowar", "The Sons of Odin", "1:30:44")
        self.playlist.add_songs([self.song, random_song, another_song])
        self.assertEqual(self.playlist.next_song(), random_song)
        self.assertEqual(self.playlist.next_song(), another_song)
        with self.assertRaises(Exception):
            self.playlist.next_song()

    def test_next_songs_with_repeat_True(self):
        random_song = Song("Random", "Random", "The Sons of Odin", "3:44")
        another_song = Song("Anther", "Kanye West", "Heartless", "4:20")
        song = Song("Baby", "J.Beiber", "Gay Album", "3:50")
        p = Playlist("p", repeat=True)
        p.add_songs([self.song, random_song, another_song, song])
        self.assertEqual(p.next_song(), random_song)
        self.assertEqual(p.next_song(), another_song)
        self.assertEqual(p.next_song(), song)
        self.assertEqual(p.next_song(), self.song)

    def test_generate_json_name(self):
        self.assertEqual(
            self.playlist.generate_json_name(), "The-sex-and-the-city.json")

    def test_save_load(self):
        song = Song("Baby", "J.Beiber", "Gay Album", "3:50")
        self.playlist.add_songs([self.song, song])
        self.playlist.save()

        g = Playlist.load("The-sex-and-the-city.json")
        self.assertEqual(self.playlist.songs, g.songs)
        self.assertEqual(g.name, "The sex and the city")

    def test_crawler_generate_ability(self):
        crawler = MusicCrawler("/home/hdimitrova/Music/Linkin Park - Meteora")
        playlist = crawler.generate_playlist("Meteora")
        self.assertEqual(playlist.total_length(), '0:36:41')

    def test_crawlered_playlist_save(self):
        crawler = MusicCrawler("/home/hdimitrova/Music/Linkin Park - Meteora")
        playlist = crawler.generate_playlist("Linkin Park - Meteora")
        playlist.save()
        playlist.pprint_playlist()
    def test_next_song_suffle_on(self):
        self.play_list = Playlist("random playlist", repeat=True)

        self.play_list.add_songs(self.songs)
        self.assertEqual(self.play_list.next_song, self.song)
        self.assertEqual(self.play_list.next_song, self.song2)
class TestPlaylist(unittest.TestCase):

    def setUp(self):
        self.s = Song("Odin", "Manowar", "The Sons of Odin", "3:44")
        self.other = Song("Odin", "Manowar", "The Sons of Odin", "3:44")
        self.other2 = Song("Odinkata", "Manowar", "The Sons of Odin", "3:4:40")
        self.my_playlist = Playlist("MyPlaylist", repeat=True, shuffle=False)

    def test_init(self):
        self.assertTrue(isinstance(self.my_playlist, Playlist))

    def test_add_song(self):
        self.my_playlist.add_song(self.s)
        self.assertTrue(self.s in self.my_playlist.songs)

    def test_add_list_of_songs(self):
        tmp = [self.other, self.other2]
        self.my_playlist.add_songs(tmp)
        self.assertTrue(self.other in self.my_playlist.songs and self.other2 in self.my_playlist.songs)

    def test_remove_song(self):
        tmp = [self.other, self.other2]
        self.my_playlist.add_songs(tmp)
        self.my_playlist.remove_song(self.other)
        self.assertFalse(self.other in self.my_playlist.songs)

    def test_total_length(self):
        tmp = [self.other, self.s]
        self.my_playlist.add_songs(tmp)
#        self.assertEqual(self.my_playlist.total_length(), "3:8:20")

        self.assertEqual(self.my_playlist.total_length(), "7:28")

    def test_artists(self):
        pass