Merge lp:~rockstar/entertainer/trial-integration into lp:entertainer

[Paul Hummer]

[Paul Hummer (rockstar)]

This branch basically just makes all tests run by twisted's trial, which will
be required when for my next branch. The run_test.py script is gone, but if
you're like me, you've been using `make test` and in which case, you'll notice
only a difference in the output.

Also, tests needed to be renamed, and while I was at it, I consolidated the
tests from entertainerlib.frontend.medialibrary.music into one single file.
That's the extent of this branch.

The diff is relatively large, but only because there was the consolidation of
the music tests.

--
Paul Hummer
http://theironlion.net
1024/862FF08F C921 E962 58F8 5547 6723 0E8C 1C4D 8AC5 862F F08F

[Matt Layman (mblayman)]

I'll approve, but I have questions.

What is the actual new work on this branch? Just removing the run_tests, renaming the files, and moving the music tests? I can see that the to_dict branch was merged in, as was the small change to GNOME from Kmos.

There are twenty missing tests (234 to 214) between the trunk and your branch. Any clue where those tests went? Did you consolidate all the music tests correctly?

review: Approve

[Paul Hummer (rockstar)]

> What is the actual new work on this branch? Just removing the run_tests,
> renaming the files, and moving the music tests? I can see that the to_dict
> branch was merged in, as was the small change to GNOME from Kmos.
>

Well, originally, I started out trying to integrate trial's python API into the
current test runner. I abandoned that idea when I realized I'd rather not
maintain more code than I needed. That's why this results in such a small
amount of work now. Smarter not harder or something like that.

> There are twenty missing tests (234 to 214) between the trunk and your
> branch. Any clue where those tests went? Did you consolidate all the music
> tests correctly?

I'm checking now, but basically, the tests were merged by doing
`cat this_test.py >> that_test.py` so I can't see how I missed something. It
might be that trial is not running inherited tests of something, where the
original test runner would have (and maybe the former is the correct
behavior). I'll verify and post what I find.

--
Paul Hummer
http://theironlion.net
1024/862FF08F C921 E962 58F8 5547 6723 0E8C 1C4D 8AC5 862F F08F

[Paul Hummer (rockstar)]

> > There are twenty missing tests (234 to 214) between the trunk and your
> > branch. Any clue where those tests went? Did you consolidate all the music
> > tests correctly?
>
> I'm checking now, but basically, the tests were merged by doing
> `cat this_test.py >> that_test.py` so I can't see how I missed something.
> It might be that trial is not running inherited tests of something, where
> the original test runner would have (and maybe the former is the correct
> behavior). I'll verify and post what I find.
>

This is wierd. I run the following command in entertainerlib/tests

 grep -r "def test" * | grep -v "NOT" | wc -l

I get 215 in both trunk and my trial branch. I THINK what was happening was
that since the tests dependent on test_music were importing test_music, it was
also bringing in the test_music tests and running them again. I don't know why
there are only 214 tests running instead of 215 like the wc command claims
there are, but I've verified that this must be a trial issue in the counting,
as it's running all the tests.

--
Paul Hummer
http://theironlion.net
1024/862FF08F C921 E962 58F8 5547 6723 0E8C 1C4D 8AC5 862F F08F

[Paul Hummer (rockstar)]

The grep command I used will yield testBackendServerCreateConfiguration that is actually commented out, so that makes sense why there are only 214 tests run. This reorganization of tests has shown us that we were running some tests more than once.

[lp:~rockstar/entertainer/trial-integration]

344. By Paul Hummer on 2009-02-04

Merge from trunk and resolve conflicts

345. By Paul Hummer on 2009-02-04

Renamed screen factory test

=== modified file '.bzrignore'
--- .bzrignore	2008-10-12 17:56:41 +0000
+++ .bzrignore	2009-01-31 21:52:10 +0000
@@ -1,2 +1,3 @@
 tags
 build
+_trial_temp

=== modified file 'Makefile'
--- Makefile	2008-12-19 05:29:55 +0000
+++ Makefile	2009-02-01 02:08:56 +0000
@@ -1,7 +1,7 @@
 PYTHON=`which python`
 VERBOSITY=-vv
 
-TEST=${PYTHON} run_tests.py
+TEST=`which trial` entertainerlib.tests
 
 LINT=pylint
 LINT_FLAGS=--rcfile=pylintrc

=== modified file 'docs/HACKING'
--- docs/HACKING	2008-10-06 01:33:50 +0000
+++ docs/HACKING	2009-02-01 02:08:56 +0000
@@ -164,8 +164,7 @@
 -----------------------------------------------------------------------
 
 There are a few things that need to be pointed out. First, the test should
-always inherit from unittest.TestCase?. The run_tests.py script looks for
-tests that inherit from unittest.TestCase? and runs those tests. Second, the
+always inherit from entertainerlib.tests.EntertainerTest?. Second, the
 test never prints anything to stdout or stderr. If the test needs to log to a
 file, that is fine, but please don't print anything to stdout or stderr.
 Lastly, the tearDown removed a file that was created by the test (and is not

=== modified file 'entertainerlib/backend/core/db/models.py'
--- entertainerlib/backend/core/db/models.py	2009-01-31 06:19:39 +0000
+++ entertainerlib/backend/core/db/models.py	2009-01-31 21:47:47 +0000
@@ -1,5 +1,5 @@
 '''Contains all storm ORM models'''
-# pylint: disable-msg=W0621
+# pylint: disable-msg=W0621,W0223
 
 from storm.base import Storm
 from storm.properties import Bool, DateTime, Int, Unicode

=== removed file 'entertainerlib/tests/Album_test.py'
--- entertainerlib/tests/Album_test.py	2009-01-11 02:51:18 +0000
+++ entertainerlib/tests/Album_test.py	1970-01-01 00:00:00 +0000
@@ -1,95 +0,0 @@
-'''Tests frontend.medialibrary.music.Album'''
-
-__licence__ = "GPLv2"
-__copyright__ = "2008, Matt Layman"
-__author__ = "Matt Layman <[e-mail]>"
-
-import os
-
-from entertainerlib.frontend.medialibrary.music import Album, AlbumHasNoTracks
-from entertainerlib.frontend.medialibrary.music import Track
-from entertainerlib.tests.Music_test import TestMusic
-
-
-class TestAlbum(TestMusic):
-    '''Tests Album'''
-
-    def setUp(self):
-        """See unittest.TestCase"""
-        TestMusic.setUp(self)
-        self.album = Album('album1', self.cursor)
-
-    def tearDown(self):
-        """Clean up after the test"""
-        TestMusic.tearDown(self)
-
-    def testAlbumConstructor(self):
-        """Test that an Album object is properly constructed"""
-        self.assertTrue(isinstance(self.album, Album))
-
-    def testAlbumConstructorNot(self):
-        """Test that an AlbumHasNoTracks exception is raised when the created
-        album doesn't exist in the cache"""
-        self.assertRaises(AlbumHasNoTracks, Album, 'foo', self.cursor)
-
-    def testAlbumStr(self):
-        """Test that title is returned in string conversion"""
-        result = str(self.album)
-        self.assertEqual(result, 'album1')
-
-    def testAlbumGetTitle(self):
-        """Test that the album title is returned"""
-        result = self.album.get_title()
-        self.assertEqual(result, 'album1')
-
-    def testAlbumHasAlbumArt(self):
-        """Test that album art exists for the file"""
-        album_artist = "artist0 - album1"
-        album_artist = album_artist.encode("base64")
-        album_art = os.path.join(self.art_path, album_artist + ".jpg")
-        file = open(album_art, "wb")
-        file.close()
-        self.assertTrue(self.album.has_album_art())
-        if os.path.exists(album_art):
-            os.remove(album_art)
-
-    def testAlbumHasAlbumArtNot(self):
-        """Test that missing album art is reported back"""
-        otherAlbum = Album('album1', self.cursor)
-        self.assertFalse(otherAlbum.has_album_art())
-
-    def testAlbumGetAlbumArtUrl(self):
-        """Test that the path to the album's art is returned"""
-        result = self.album.get_album_art_url()
-        album_artist = "artist0 - album1"
-        album_artist = album_artist.encode("base64")
-        album_art = os.path.join(self.art_path, album_artist + ".jpg")
-        self.assertEqual(result, album_art)
-
-    def testAlbumGetTracks(self):
-        """Test that all tracks for an album are returned"""
-        result = self.album.get_tracks()
-        self.assertEqual(len(result), 4)
-        for i in result:
-            self.assertTrue(isinstance(i, Track))
-
-    def testAlbumGetNumberOfTracks(self):
-        """Test correct number of tracks from album is returned"""
-        self.assertEqual(self.album.get_number_of_tracks(), 4)
-
-    def testAlbumGetYear(self):
-        """Test that year of album is returned"""
-        self.assertEqual(self.album.get_year(), 0)
-
-    def testAlbumGetGenre(self):
-        """Test that genre of album is returned"""
-        self.assertEqual(self.album.get_genre(), 'genre0')
-
-    def testAlbumGetArtist(self):
-        """Test that artist of album is returned"""
-        self.assertEqual(self.album.get_artist(), 'artist0')
-
-    def testAlbumGetTotalLength(self):
-        """Test that total length of album is returned"""
-        self.assertEqual(self.album.get_total_length(), 8)
-

=== removed file 'entertainerlib/tests/MusicLibrary_test.py'
--- entertainerlib/tests/MusicLibrary_test.py	2009-01-11 02:51:18 +0000
+++ entertainerlib/tests/MusicLibrary_test.py	1970-01-01 00:00:00 +0000
@@ -1,132 +0,0 @@
-'''Tests MusicLibrary'''
-
-__licence__ = "GPLv2"
-__copyright__ = "2008, Matt Layman"
-__author__ = "Matt Layman <[e-mail]>"
-
-from entertainerlib.frontend.medialibrary.music import MusicLibrary
-from entertainerlib.frontend.medialibrary.music import Album, Track
-from entertainerlib.tests.Music_test import TestMusic
-from entertainerlib.tests.helpers import MockBackendConnection
-
-class TestMusicLibrary(TestMusic):
-    '''Tests MusicLibrary'''
-
-    def setUp(self):
-        TestMusic.setUp(self)
-        try:
-            self.backend_connection = MockBackendConnection()
-        except:
-            print "\nbackend_connection failed"
-        self.musiclibrary = MusicLibrary(self.backend_connection)
-
-    def tearDown(self):
-        self.backend_connection.close_connection()
-        TestMusic.tearDown(self)
-
-    def testMusicLibraryConstructor(self):
-        """testMusicLibraryContructor - Ensures instantiation of MusicLibrary
-        class"""
-        self.assertTrue(isinstance(self.musiclibrary, MusicLibrary))
-
-    def testGetAllArtists(self):
-        """testGetAllArtists - Ensures that all artists are returned from
-        the music library"""
-        result = self.musiclibrary.get_all_artists()
-        self.assertEqual(result, ['artist0'])
-
-    def testGetAllTracks(self):
-        """testGetAllTracks - Ensures that all tracks are returned"""
-        result = self.musiclibrary.get_all_tracks()
-        for i in result:
-            self.assertTrue(isinstance(i, Track))
-        self.assertEqual(len(result), 8)
-
-    def testGetTracksByGenre(self):
-        """testGetTracksByGenre - Ensures tracks of a certain genre are
-        returned"""
-        result = self.musiclibrary.get_tracks_by_genre('genre0')
-        self.assertEqual(len(result), 4)
-        for i in result:
-            self.assertEqual(i.get_genre(), 'genre0')
-
-    def testGetTracksByMissingGenre(self):
-        """testGetTracksByMissingGenre - Ensures proper handling of a missing
-        genre"""
-        self.assertEquals(
-            len(self.musiclibrary.get_tracks_by_genre('foo-bar-baz**')), 0)
-
-    def testGetTracksByArtist(self):
-        """testGetTracksByArtist - Ensure tracks by a certain artist are
-        returned"""
-        result = self.musiclibrary.get_tracks_by_artist('artist0')
-        self.assertEqual(len(result), 8)
-        for i in result:
-            self.assertEqual(i.get_artist(), 'artist0')
-
-    def testGetTracksByUnknownArtist(self):
-        """testGetTracksByUnknownArtist - Ensure proper handling of an missing
-        artist in the cache"""
-        self.assertEquals(
-            len(self.musiclibrary.get_tracks_by_artist('foo')), 0)
-
-    def testGetAllAlbums(self):
-        """testGetAllAlbums - Ensures all albums are returned"""
-        result = self.musiclibrary.get_all_albums()
-        for i in result:
-            self.assertTrue(isinstance(i, Album))
-        self.assertEqual(len(result), 2)
-
-    def testGetAlbumsByArtist(self):
-        """testGetAlbumsByArtist - Ensures correct albums by an artist is
-        returned"""
-        result = self.musiclibrary.get_albums_by_artist('artist0')
-        self.assertEqual(len(result), 2)
-        for i in result:
-            self.assertEqual(i.get_artist(), 'artist0')
-
-    def testGetAlbumsByUnknownArtist(self):
-        """testGetAlbumsByUnknownArtist - Ensures proper handling of an
-        artist not in the cache"""
-        self.assertEquals(
-            len(self.musiclibrary.get_albums_by_artist('foo')), 0)
-
-    def testNumberOfTracks(self):
-        """testNumberOfTracks - Ensures number of all tracks is returned"""
-        result = self.musiclibrary.number_of_tracks()
-        self.assertEqual(result, 8)
-
-    def testNumberOfTracksByArtist(self):
-        """testNumberOfTracksByArtist - Ensures number of all tracks by one
-        artist is returned"""
-        result = self.musiclibrary.number_of_tracks_by_artist('artist0')
-        self.assertEqual(result, 8)
-
-    def testNumberOfTracksByUnknownArtist(self):
-        """testNumberOfTracksByUnknownArtist - Ensures proper handling when
-        artist called is not in the cache"""
-        self.assertEqual(
-            self.musiclibrary.number_of_albums_by_artist('foo'), 0)
-
-    def testNumberOfAlbumsByArtist(self):
-        """testNumberOfAlbumsByArtist - Ensures number of all albums by one
-        artist is returned"""
-        result = self.musiclibrary.number_of_albums_by_artist('artist0')
-        self.assertEqual(result, 2)
-
-    def testNumberOfAlbumsByUnknownArtist(self):
-        """testNumberOfAlbumsByUnknownArtist - Ensures proper handling when
-        artist called is not in the cache"""
-        self.assertEqual(
-            self.musiclibrary.number_of_albums_by_artist('foo'), 0)
-
-    def testSaveLyrics(self):
-        """testSaveLyrics - Ensures lyrics for a track are saved in the
-        database"""
-        # Only need a filename that matches something in the database, the rest
-        # of the track is for construction purposes only
-        self.track = Track('/filename/000', '', 0, '', '', '', '', 0, 1, 0, '',
-                           '')
-        self.musiclibrary.save_lyrics(self.track, 'some lyrics here')
-        self.assertEqual(self.track.get_lyrics(), 'some lyrics here')
-

=== removed file 'entertainerlib/tests/README'
--- entertainerlib/tests/README	2008-02-04 01:45:58 +0000
+++ entertainerlib/tests/README	1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-How to run Entertainer tests:
-
-I'll make this easy for you...
-
-./run_tests.py
-
-That's it.  Then watch it go.

=== removed file 'entertainerlib/tests/Track_test.py'
--- entertainerlib/tests/Track_test.py	2008-12-25 01:21:19 +0000
+++ entertainerlib/tests/Track_test.py	1970-01-01 00:00:00 +0000
@@ -1,176 +0,0 @@
-'''Test Track'''
-
-__licence__ = "GPLv2"
-__copyright__ = "2008, Matt Layman"
-__author__ = "Matt Layman <[e-mail]>"
-
-import os
-
-from entertainerlib.frontend.medialibrary.music import Track, TrackTypeError
-from entertainerlib.frontend.medialibrary.music import TrackRatingOutOfRange
-from entertainerlib.frontend.medialibrary.music import Album, AlbumHasNoTracks
-from entertainerlib.frontend.medialibrary.playable import Playable
-from entertainerlib.tests.Music_test import TestMusic
-
-
-class TestTrack(TestMusic):
-
-    def setUp(self):
-        TestMusic.setUp(self)
-        self.track = Track('/path/to/track.mp3', # filename
-                           'title',
-                           1, # tracknumber
-                           'artist0',
-                           'album0',
-                           'genre',
-                           '128', # bitrate
-                           2008, # year
-                           5, # rating
-                           240, # length
-                           'comment',
-                           'lyrics')
-
-    def tearDown(self):
-        TestMusic.tearDown(self)
-
-    def testTrackConstructor(self):
-        """testTrackConstructor - Ensures that a Track object is created"""
-        self.assertTrue(isinstance(self.track, Track))
-
-    def testTrackBadConstructor(self):
-        """testTrackBadConstructor - Ensures that bad track construction
-        raises an exception for the integer fields"""
-        for i in [2, 7, 8, 9]:
-            t = ['a', 'b', 1, 'c', 'd', 'e', 'f', 2, 3, 4, 'g', 'h']
-            t[i] = str(t[i])
-            self.assertRaises(TrackTypeError, Track, t[0], t[1], t[2], t[3],
-                              t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11])
-
-    def testTrackRatingInRange(self):
-        """testTrackRatingInRange - Ensures that the ratings in range create
-        valid Track objects"""
-        for i in range(1, 6):
-            self.track = Track('a', 'b', 1, 'c', 'd', 'e', 'f', 2, i, 3, 'g',
-                               'h')
-            self.assertTrue(isinstance(self.track, Track))
-            self.assertEqual(self.track.get_rating(), i)
-
-    def testTrackRatingOutOfRange(self):
-        """testTrackRatingOutOfRange - Ensures that the rating raises an
-        exception for something out of range in construction"""
-        for i in [0, 6]:
-            self.assertRaises(TrackRatingOutOfRange, Track, 'a', 'b', 1, 'c',
-                              'd', 'e', 'f', 2, i, 3, 'g', 'h')
-
-    def testTrackGetFilename(self):
-        """testTrackGetFilename - Ensures that the filename is returned"""
-        result = self.track.get_filename()
-        self.assertEqual(result, '/path/to/track.mp3')
-
-    def testTrackGetTitle(self):
-        """testTrackGetTitle - Ensures that the title is returned"""
-        result = self.track.get_title()
-        self.assertEqual(result, 'title')
-
-    def testTrackGetTrackNumber(self):
-        """testTrackGetTrackNumber - Ensures that the tracknumber is
-        returned"""
-        result = self.track.get_tracknumber()
-        self.assertEqual(result, 1)
-
-    def testTrackGetArtist(self):
-        """testTrackGetArtist - Ensures that the artist is returned"""
-        result = self.track.get_artist()
-        self.assertEqual(result, 'artist0')
-
-    def testTrackGetAlbum(self):
-        """testTrackGetAlbum - Ensures that an album object is returned"""
-        result = self.track.get_album(self.cursor)
-        self.assertTrue(isinstance(result, Album))
-        self.assertEqual(result.get_title(), 'album0')
-
-    def testTrackGetAlbumNot(self):
-        """testTrackGetAlbumNot - Ensures that a bad album in the track
-        returns AlbumHasNoTracks"""
-        self.badTrack = Track('path', 'title', 1, 'artist',
-                              'foo-bar-baz**', # Here is the bad input
-                              'genre', '128', 2008, 5, 240, 'comment',
-                              'lyrics')
-        self.assertRaises(AlbumHasNoTracks, self.badTrack.get_album,
-                          self.cursor)
-
-    def testTrackGetAlbumArtUrlExists(self):
-        """testTrackGetAlbumArtUrl - Ensures that the album art url is
-        returned"""
-        album_artist = "artist0 - album0"
-        album_artist = album_artist.encode("base64")
-        album_art = os.path.join(self.art_path, album_artist + ".jpg")
-        file = open(album_art, "wb")
-        file.close()
-        result = self.track.get_album_art_url(self.cursor)
-        self.assertEqual(result, album_art)
-        if os.path.exists(album_art):
-            os.remove(album_art)
-
-    def testTrackGetAlbumArtUrlNotExists(self):
-        """testTrackGetAlbumArtUrlNotExists - Ensures that when art does
-        not exist, None is returned"""
-        result = self.track.get_album_art_url(self.cursor)
-        self.assertEqual(result, None)
-
-    def testTrackGetGenre(self):
-        """testTrackGetGenre - Ensures that the genre is returned"""
-        result = self.track.get_genre()
-        self.assertEqual(result, 'genre')
-
-    def testTrackGetBitrate(self):
-        """testTrackGetBitrate - Ensures that the bitrate is returned"""
-        result = self.track.get_bitrate()
-        self.assertEqual(result, '128')
-
-    def testTrackGetYear(self):
-        """testTrackGetYear - Ensures that the year is returned"""
-        result = self.track.get_year()
-        self.assertEqual(result, 2008)
-
-    def testTrackGetRating(self):
-        """testTrackGetRating - Ensures that the rating is returned"""
-        result = self.track.get_rating()
-        self.assertEqual(result, 5)
-
-    def testTrackGetLength(self):
-        """testTrackGetLength - Ensures that the length is returned"""
-        result = self.track.get_length()
-        self.assertEqual(result, 240)
-
-    def testTrackGetComment(self):
-        """testTrackGetComment - Ensures that the comment is returned"""
-        result = self.track.get_comment()
-        self.assertEqual(result, 'comment')
-
-    def testTrackGetLyrics(self):
-        """testTrackGetLyrics - Ensures that the lyrics are returned"""
-        result = self.track.get_lyrics()
-        self.assertEqual(result, 'lyrics')
-
-    def testTrackSetLyrics(self):
-        """testTrackSetLyrics - Ensures that lyrics are properly set"""
-        self.track.set_lyrics('some new lyrics')
-        self.assertEqual(self.track.get_lyrics(), 'some new lyrics')
-
-    def testTrackSetNoneLyrics(self):
-        """testTrackSetNoneLyrics - Ensures that lyrics are set to empty
-        string when None is passed as lyrics input"""
-        self.track.set_lyrics(None)
-        self.assertEqual(self.track.get_lyrics(), '')
-
-    def testTrackGetType(self):
-        """testTrackGetType - Ensures that the type is returned"""
-        result = self.track.get_type()
-        self.assertEqual(result, Playable.AUDIO_STREAM)
-
-    def testTrackGetUri(self):
-        """testTrackGetUri - Ensures that the uri is returned"""
-        result = self.track.get_uri()
-        self.assertEqual(result, 'file:///path/to/track.mp3')
-

=== modified file 'entertainerlib/tests/__init__.py'
--- entertainerlib/tests/__init__.py	2009-01-11 22:29:20 +0000
+++ entertainerlib/tests/__init__.py	2009-02-01 01:51:12 +0000
@@ -6,8 +6,10 @@
 import testtools
 
 from entertainerlib.backend.core.db.connection import Database
+from entertainerlib.frontend.translation_setup import TranslationSetup
 from entertainerlib.utils.configuration import Configuration
 
+TranslationSetup()
 
 class EntertainerTest(testtools.TestCase):
     '''Test for use in the Entertainer test suite.'''

=== renamed file 'entertainerlib/tests/BackendServer_test.py' => 'entertainerlib/tests/test_backendserver.py'
=== renamed file 'entertainerlib/tests/Base_test.py' => 'entertainerlib/tests/test_base.py'
=== renamed file 'entertainerlib/tests/Configuration_test.py' => 'entertainerlib/tests/test_configuration.py'
=== renamed file 'entertainerlib/tests/ConnectionServer_test.py' => 'entertainerlib/tests/test_connection.py'
=== renamed file 'entertainerlib/tests/Database_test.py' => 'entertainerlib/tests/test_database.py'
=== renamed file 'entertainerlib/tests/FeedConfigTools_test.py' => 'entertainerlib/tests/test_feedconfigtools.py'
=== renamed file 'entertainerlib/tests/FeedEntryParser_test.py' => 'entertainerlib/tests/test_feedentryparser.py'
=== renamed file 'entertainerlib/tests/FrontendFeed_test.py' => 'entertainerlib/tests/test_frontendfeed.py'
=== renamed file 'entertainerlib/tests/FrontendFeedEntry_test.py' => 'entertainerlib/tests/test_frontendfeedentry.py'
=== renamed file 'entertainerlib/tests/FrontendFeedLibrary_test.py' => 'entertainerlib/tests/test_frontendfeedlibrary.py'
=== renamed file 'entertainerlib/tests/ImageMenuItem_test.py' => 'entertainerlib/tests/test_imagemenuitem.py'
=== renamed file 'entertainerlib/tests/ImageThumbnailer_test.py' => 'entertainerlib/tests/test_imagethumbnailer.py'
=== renamed file 'entertainerlib/tests/Label_test.py' => 'entertainerlib/tests/test_label.py'
=== renamed file 'entertainerlib/tests/Logger_test.py' => 'entertainerlib/tests/test_logger.py'
=== renamed file 'entertainerlib/tests/LyricsDownloader_test.py' => 'entertainerlib/tests/test_lyricsdownloader.py'
=== renamed file 'entertainerlib/tests/MessageType_test.py' => 'entertainerlib/tests/test_messagetype.py'
=== renamed file 'entertainerlib/tests/Models_test.py' => 'entertainerlib/tests/test_models.py'
=== renamed file 'entertainerlib/tests/Music_test.py' => 'entertainerlib/tests/test_music.py'
--- entertainerlib/tests/Music_test.py	2009-01-11 03:12:02 +0000
+++ entertainerlib/tests/test_music.py	2009-02-01 01:51:12 +0000
@@ -4,9 +4,16 @@
 __copyright__ = "2008, Matt Layman"
 __author__ = "Matt Layman <[e-mail]>"
 
+import os
+
 from pysqlite2 import dbapi2 as sqlite
 
+from entertainerlib.frontend.medialibrary.music import (
+    Album, AlbumHasNoTracks, MusicLibrary, Track, TrackRatingOutOfRange,
+    TrackTypeError)
+from entertainerlib.frontend.medialibrary.playable import Playable
 from entertainerlib.tests import EntertainerTest
+from entertainerlib.tests.helpers import MockBackendConnection
 
 class TestMusic(EntertainerTest):
     """This test class sets up the test database required for all test
@@ -77,3 +84,370 @@
         connection.commit()
         connection.close()
 
+
+class TestTrack(TestMusic):
+
+    def setUp(self):
+        TestMusic.setUp(self)
+        self.track = Track('/path/to/track.mp3', # filename
+                           'title',
+                           1, # tracknumber
+                           'artist0',
+                           'album0',
+                           'genre',
+                           '128', # bitrate
+                           2008, # year
+                           5, # rating
+                           240, # length
+                           'comment',
+                           'lyrics')
+
+    def tearDown(self):
+        TestMusic.tearDown(self)
+
+    def testTrackConstructor(self):
+        """testTrackConstructor - Ensures that a Track object is created"""
+        self.assertTrue(isinstance(self.track, Track))
+
+    def testTrackBadConstructor(self):
+        """testTrackBadConstructor - Ensures that bad track construction
+        raises an exception for the integer fields"""
+        for i in [2, 7, 8, 9]:
+            t = ['a', 'b', 1, 'c', 'd', 'e', 'f', 2, 3, 4, 'g', 'h']
+            t[i] = str(t[i])
+            self.assertRaises(TrackTypeError, Track, t[0], t[1], t[2], t[3],
+                              t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11])
+
+    def testTrackRatingInRange(self):
+        """testTrackRatingInRange - Ensures that the ratings in range create
+        valid Track objects"""
+        for i in range(1, 6):
+            self.track = Track('a', 'b', 1, 'c', 'd', 'e', 'f', 2, i, 3, 'g',
+                               'h')
+            self.assertTrue(isinstance(self.track, Track))
+            self.assertEqual(self.track.get_rating(), i)
+
+    def testTrackRatingOutOfRange(self):
+        """testTrackRatingOutOfRange - Ensures that the rating raises an
+        exception for something out of range in construction"""
+        for i in [0, 6]:
+            self.assertRaises(TrackRatingOutOfRange, Track, 'a', 'b', 1, 'c',
+                              'd', 'e', 'f', 2, i, 3, 'g', 'h')
+
+    def testTrackGetFilename(self):
+        """testTrackGetFilename - Ensures that the filename is returned"""
+        result = self.track.get_filename()
+        self.assertEqual(result, '/path/to/track.mp3')
+
+    def testTrackGetTitle(self):
+        """testTrackGetTitle - Ensures that the title is returned"""
+        result = self.track.get_title()
+        self.assertEqual(result, 'title')
+
+    def testTrackGetTrackNumber(self):
+        """testTrackGetTrackNumber - Ensures that the tracknumber is
+        returned"""
+        result = self.track.get_tracknumber()
+        self.assertEqual(result, 1)
+
+    def testTrackGetArtist(self):
+        """testTrackGetArtist - Ensures that the artist is returned"""
+        result = self.track.get_artist()
+        self.assertEqual(result, 'artist0')
+
+    def testTrackGetAlbum(self):
+        """testTrackGetAlbum - Ensures that an album object is returned"""
+        result = self.track.get_album(self.cursor)
+        self.assertTrue(isinstance(result, Album))
+        self.assertEqual(result.get_title(), 'album0')
+
+    def testTrackGetAlbumNot(self):
+        """testTrackGetAlbumNot - Ensures that a bad album in the track
+        returns AlbumHasNoTracks"""
+        self.badTrack = Track('path', 'title', 1, 'artist',
+                              'foo-bar-baz**', # Here is the bad input
+                              'genre', '128', 2008, 5, 240, 'comment',
+                              'lyrics')
+        self.assertRaises(AlbumHasNoTracks, self.badTrack.get_album,
+                          self.cursor)
+
+    def testTrackGetAlbumArtUrlExists(self):
+        """testTrackGetAlbumArtUrl - Ensures that the album art url is
+        returned"""
+        album_artist = "artist0 - album0"
+        album_artist = album_artist.encode("base64")
+        album_art = os.path.join(self.art_path, album_artist + ".jpg")
+        file = open(album_art, "wb")
+        file.close()
+        result = self.track.get_album_art_url(self.cursor)
+        self.assertEqual(result, album_art)
+        if os.path.exists(album_art):
+            os.remove(album_art)
+
+    def testTrackGetAlbumArtUrlNotExists(self):
+        """testTrackGetAlbumArtUrlNotExists - Ensures that when art does
+        not exist, None is returned"""
+        result = self.track.get_album_art_url(self.cursor)
+        self.assertEqual(result, None)
+
+    def testTrackGetGenre(self):
+        """testTrackGetGenre - Ensures that the genre is returned"""
+        result = self.track.get_genre()
+        self.assertEqual(result, 'genre')
+
+    def testTrackGetBitrate(self):
+        """testTrackGetBitrate - Ensures that the bitrate is returned"""
+        result = self.track.get_bitrate()
+        self.assertEqual(result, '128')
+
+    def testTrackGetYear(self):
+        """testTrackGetYear - Ensures that the year is returned"""
+        result = self.track.get_year()
+        self.assertEqual(result, 2008)
+
+    def testTrackGetRating(self):
+        """testTrackGetRating - Ensures that the rating is returned"""
+        result = self.track.get_rating()
+        self.assertEqual(result, 5)
+
+    def testTrackGetLength(self):
+        """testTrackGetLength - Ensures that the length is returned"""
+        result = self.track.get_length()
+        self.assertEqual(result, 240)
+
+    def testTrackGetComment(self):
+        """testTrackGetComment - Ensures that the comment is returned"""
+        result = self.track.get_comment()
+        self.assertEqual(result, 'comment')
+
+    def testTrackGetLyrics(self):
+        """testTrackGetLyrics - Ensures that the lyrics are returned"""
+        result = self.track.get_lyrics()
+        self.assertEqual(result, 'lyrics')
+
+    def testTrackSetLyrics(self):
+        """testTrackSetLyrics - Ensures that lyrics are properly set"""
+        self.track.set_lyrics('some new lyrics')
+        self.assertEqual(self.track.get_lyrics(), 'some new lyrics')
+
+    def testTrackSetNoneLyrics(self):
+        """testTrackSetNoneLyrics - Ensures that lyrics are set to empty
+        string when None is passed as lyrics input"""
+        self.track.set_lyrics(None)
+        self.assertEqual(self.track.get_lyrics(), '')
+
+    def testTrackGetType(self):
+        """testTrackGetType - Ensures that the type is returned"""
+        result = self.track.get_type()
+        self.assertEqual(result, Playable.AUDIO_STREAM)
+
+    def testTrackGetUri(self):
+        """testTrackGetUri - Ensures that the uri is returned"""
+        result = self.track.get_uri()
+        self.assertEqual(result, 'file:///path/to/track.mp3')
+
+
+class TestMusicLibrary(TestMusic):
+    '''Tests MusicLibrary'''
+
+    def setUp(self):
+        TestMusic.setUp(self)
+        try:
+            self.backend_connection = MockBackendConnection()
+        except:
+            print "\nbackend_connection failed"
+        self.musiclibrary = MusicLibrary(self.backend_connection)
+
+    def tearDown(self):
+        self.backend_connection.close_connection()
+        TestMusic.tearDown(self)
+
+    def testMusicLibraryConstructor(self):
+        """testMusicLibraryContructor - Ensures instantiation of MusicLibrary
+        class"""
+        self.assertTrue(isinstance(self.musiclibrary, MusicLibrary))
+
+    def testGetAllArtists(self):
+        """testGetAllArtists - Ensures that all artists are returned from
+        the music library"""
+        result = self.musiclibrary.get_all_artists()
+        self.assertEqual(result, ['artist0'])
+
+    def testGetAllTracks(self):
+        """testGetAllTracks - Ensures that all tracks are returned"""
+        result = self.musiclibrary.get_all_tracks()
+        for i in result:
+            self.assertTrue(isinstance(i, Track))
+        self.assertEqual(len(result), 8)
+
+    def testGetTracksByGenre(self):
+        """testGetTracksByGenre - Ensures tracks of a certain genre are
+        returned"""
+        result = self.musiclibrary.get_tracks_by_genre('genre0')
+        self.assertEqual(len(result), 4)
+        for i in result:
+            self.assertEqual(i.get_genre(), 'genre0')
+
+    def testGetTracksByMissingGenre(self):
+        """testGetTracksByMissingGenre - Ensures proper handling of a missing
+        genre"""
+        self.assertEquals(
+            len(self.musiclibrary.get_tracks_by_genre('foo-bar-baz**')), 0)
+
+    def testGetTracksByArtist(self):
+        """testGetTracksByArtist - Ensure tracks by a certain artist are
+        returned"""
+        result = self.musiclibrary.get_tracks_by_artist('artist0')
+        self.assertEqual(len(result), 8)
+        for i in result:
+            self.assertEqual(i.get_artist(), 'artist0')
+
+    def testGetTracksByUnknownArtist(self):
+        """testGetTracksByUnknownArtist - Ensure proper handling of an missing
+        artist in the cache"""
+        self.assertEquals(
+            len(self.musiclibrary.get_tracks_by_artist('foo')), 0)
+
+    def testGetAllAlbums(self):
+        """testGetAllAlbums - Ensures all albums are returned"""
+        result = self.musiclibrary.get_all_albums()
+        for i in result:
+            self.assertTrue(isinstance(i, Album))
+        self.assertEqual(len(result), 2)
+
+    def testGetAlbumsByArtist(self):
+        """testGetAlbumsByArtist - Ensures correct albums by an artist is
+        returned"""
+        result = self.musiclibrary.get_albums_by_artist('artist0')
+        self.assertEqual(len(result), 2)
+        for i in result:
+            self.assertEqual(i.get_artist(), 'artist0')
+
+    def testGetAlbumsByUnknownArtist(self):
+        """testGetAlbumsByUnknownArtist - Ensures proper handling of an
+        artist not in the cache"""
+        self.assertEquals(
+            len(self.musiclibrary.get_albums_by_artist('foo')), 0)
+
+    def testNumberOfTracks(self):
+        """testNumberOfTracks - Ensures number of all tracks is returned"""
+        result = self.musiclibrary.number_of_tracks()
+        self.assertEqual(result, 8)
+
+    def testNumberOfTracksByArtist(self):
+        """testNumberOfTracksByArtist - Ensures number of all tracks by one
+        artist is returned"""
+        result = self.musiclibrary.number_of_tracks_by_artist('artist0')
+        self.assertEqual(result, 8)
+
+    def testNumberOfTracksByUnknownArtist(self):
+        """testNumberOfTracksByUnknownArtist - Ensures proper handling when
+        artist called is not in the cache"""
+        self.assertEqual(
+            self.musiclibrary.number_of_albums_by_artist('foo'), 0)
+
+    def testNumberOfAlbumsByArtist(self):
+        """testNumberOfAlbumsByArtist - Ensures number of all albums by one
+        artist is returned"""
+        result = self.musiclibrary.number_of_albums_by_artist('artist0')
+        self.assertEqual(result, 2)
+
+    def testNumberOfAlbumsByUnknownArtist(self):
+        """testNumberOfAlbumsByUnknownArtist - Ensures proper handling when
+        artist called is not in the cache"""
+        self.assertEqual(
+            self.musiclibrary.number_of_albums_by_artist('foo'), 0)
+
+    def testSaveLyrics(self):
+        """testSaveLyrics - Ensures lyrics for a track are saved in the
+        database"""
+        # Only need a filename that matches something in the database, the rest
+        # of the track is for construction purposes only
+        self.track = Track('/filename/000', '', 0, '', '', '', '', 0, 1, 0, '',
+                           '')
+        self.musiclibrary.save_lyrics(self.track, 'some lyrics here')
+        self.assertEqual(self.track.get_lyrics(), 'some lyrics here')
+
+
+class TestAlbum(TestMusic):
+    '''Tests Album'''
+
+    def setUp(self):
+        """See unittest.TestCase"""
+        TestMusic.setUp(self)
+        self.album = Album('album1', self.cursor)
+
+    def tearDown(self):
+        """Clean up after the test"""
+        TestMusic.tearDown(self)
+
+    def testAlbumConstructor(self):
+        """Test that an Album object is properly constructed"""
+        self.assertTrue(isinstance(self.album, Album))
+
+    def testAlbumConstructorNot(self):
+        """Test that an AlbumHasNoTracks exception is raised when the created
+        album doesn't exist in the cache"""
+        self.assertRaises(AlbumHasNoTracks, Album, 'foo', self.cursor)
+
+    def testAlbumStr(self):
+        """Test that title is returned in string conversion"""
+        result = str(self.album)
+        self.assertEqual(result, 'album1')
+
+    def testAlbumGetTitle(self):
+        """Test that the album title is returned"""
+        result = self.album.get_title()
+        self.assertEqual(result, 'album1')
+
+    def testAlbumHasAlbumArt(self):
+        """Test that album art exists for the file"""
+        album_artist = "artist0 - album1"
+        album_artist = album_artist.encode("base64")
+        album_art = os.path.join(self.art_path, album_artist + ".jpg")
+        file = open(album_art, "wb")
+        file.close()
+        self.assertTrue(self.album.has_album_art())
+        if os.path.exists(album_art):
+            os.remove(album_art)
+
+    def testAlbumHasAlbumArtNot(self):
+        """Test that missing album art is reported back"""
+        otherAlbum = Album('album1', self.cursor)
+        self.assertFalse(otherAlbum.has_album_art())
+
+    def testAlbumGetAlbumArtUrl(self):
+        """Test that the path to the album's art is returned"""
+        result = self.album.get_album_art_url()
+        album_artist = "artist0 - album1"
+        album_artist = album_artist.encode("base64")
+        album_art = os.path.join(self.art_path, album_artist + ".jpg")
+        self.assertEqual(result, album_art)
+
+    def testAlbumGetTracks(self):
+        """Test that all tracks for an album are returned"""
+        result = self.album.get_tracks()
+        self.assertEqual(len(result), 4)
+        for i in result:
+            self.assertTrue(isinstance(i, Track))
+
+    def testAlbumGetNumberOfTracks(self):
+        """Test correct number of tracks from album is returned"""
+        self.assertEqual(self.album.get_number_of_tracks(), 4)
+
+    def testAlbumGetYear(self):
+        """Test that year of album is returned"""
+        self.assertEqual(self.album.get_year(), 0)
+
+    def testAlbumGetGenre(self):
+        """Test that genre of album is returned"""
+        self.assertEqual(self.album.get_genre(), 'genre0')
+
+    def testAlbumGetArtist(self):
+        """Test that artist of album is returned"""
+        self.assertEqual(self.album.get_artist(), 'artist0')
+
+    def testAlbumGetTotalLength(self):
+        """Test that total length of album is returned"""
+        self.assertEqual(self.album.get_total_length(), 8)
+

=== renamed file 'entertainerlib/tests/OPMLParser_test.py' => 'entertainerlib/tests/test_opmlparser.py'
=== renamed file 'entertainerlib/tests/Screen_test.py' => 'entertainerlib/tests/test_screen.py'
=== renamed file 'entertainerlib/tests/ScrollArea_test.py' => 'entertainerlib/tests/test_scrollarea.py'
=== renamed file 'entertainerlib/tests/SystemTrayMessageHandler_test.py' => 'entertainerlib/tests/test_systemtraymessagehandler.py'
=== renamed file 'entertainerlib/tests/Texture_test.py' => 'entertainerlib/tests/test_texture.py'
=== renamed file 'entertainerlib/tests/Theme_test.py' => 'entertainerlib/tests/test_theme.py'
=== renamed file 'entertainerlib/tests/Thumbnailer_test.py' => 'entertainerlib/tests/test_thumbnailer.py'
=== renamed file 'entertainerlib/tests/TransitionFactory_test.py' => 'entertainerlib/tests/test_transitionfactory.py'
=== renamed file 'entertainerlib/tests/VideoMetadataSearch_test.py' => 'entertainerlib/tests/test_videometadatasearch.py'
=== renamed file 'entertainerlib/tests/VideoThumbnailer_test.py' => 'entertainerlib/tests/test_videothumbnailer.py'
=== renamed file 'entertainerlib/tests/Weather_test.py' => 'entertainerlib/tests/test_weather.py'
=== removed file 'run_tests.py'
--- run_tests.py	2009-01-11 20:10:22 +0000
+++ run_tests.py	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-#!/usr/bin/env python
-'''Entertainer test runner'''
-
-import os
-import shutil
-import sys
-import unittest
-
-from entertainerlib.frontend.translation_setup import TranslationSetup
-
-TOP_LEVEL_DIR = os.path.abspath('.')
-
-IGNORE_FILES = []
-
-TranslationSetup()
-
-suite = unittest.TestSuite()
-debug = False
-
-try:
-    descriptions = sys.argv[1]
-    verbosity = sys.argv[1]
-except IndexError:
-    descriptions = 0
-    verbosity = 0
-
-try:
-    if sys.argv[2] == '1':
-        debug = True
-except IndexError:
-    pass
-
-# Clean up the cfg_dir between runs
-test_cfg = '/tmp/cfg_dir'
-if os.path.exists(test_cfg):
-    shutil.rmtree(test_cfg)
-
-for file in os.listdir(TOP_LEVEL_DIR + '/entertainerlib/tests/'):
-    if file in IGNORE_FILES:
-        continue
-    if file[-8:] != '_test.py':
-        continue
-    import_name = 'entertainerlib.tests.' + file[:-3]
-    if debug:
-        print 'Found test : %s' % import_name
-    suite.addTest(
-        unittest.defaultTestLoader.loadTestsFromName(import_name)
-        )
-
-test_runner = unittest.TextTestRunner(descriptions=descriptions,
-    verbosity=verbosity)
-result = test_runner.run(suite)
-if result.failures or result.errors:
-    sys.exit(1)