Merge lp:~thisfred/autoqueue/lp-777355 into lp:autoqueue

[Eric Casteleijn]

Fixed tests and removed hopelessly broken ones.

Fixed tests and removed hopelessly broken ones.

=== modified file 'autoqueue/__init__.py'
--- autoqueue/__init__.py	2011-05-03 16:30:52 +0000
+++ autoqueue/__init__.py	2011-05-06 00:06:43 +0000
@@ -333,7 +333,7 @@
             else:
                 try:
                     excluded_filenames.append(unicode(filename, 'utf-8'))
-                except:
+                except UnicodeDecodeError:
                     self.log('Could not decode filename: %r' % filename)
         filename = song.get_filename()
         try:
@@ -343,7 +343,7 @@
             self.similarity.analyze_track(
                 filename, True, excluded_filenames, 5, reply_handler=NO_OP,
                 error_handler=NO_OP, timeout=300)
-        except:
+        except UnicodeDecodeError:
             self.log('Could not decode filename: %r' % filename)
         if self.desired_queue_length == 0 or self.queue_needs_songs():
             self.fill_queue()
@@ -387,7 +387,7 @@
                 if not isinstance(filename, unicode):
                     try:
                         filename = filename.decode('utf-8')
-                    except:
+                    except UnicodeDecodeError:
                         self.log('failed to decode filename %r' % filename)
                 self.similarity.remove_track_by_filename(
                     filename, reply_handler=NO_OP,
@@ -438,7 +438,7 @@
             else:
                 try:
                     excluded_filenames.append(unicode(filename, 'utf-8'))
-                except:
+                except UnicodeDecodeError:
                     self.log('Could not decode filename: %r' % filename)
         filename = song.get_filename()
         try:
@@ -449,7 +449,7 @@
                 filename, True, excluded_filenames, 0,
                 reply_handler=self.analyzed,
                 error_handler=self.error_handler, timeout=300)
-        except:
+        except UnicodeDecodeError:
             self.log('Could not decode filename: %r' % filename)
 
     def analyzed(self):
@@ -462,7 +462,7 @@
                 filename,
                 reply_handler=self.mirage_reply_handler,
                 error_handler=self.error_handler, timeout=300)
-        except:
+        except UnicodeDecodeError:
             self.log('Could not decode filename: %r' % filename)
 
     def done(self):
@@ -475,7 +475,7 @@
             else:
                 try:
                     excluded_filenames.append(unicode(filename, 'utf-8'))
-                except:
+                except UnicodeDecodeError:
                     self.log('Could not decode filename: %r' % filename)
         filename = song.get_filename()
         try:
@@ -486,7 +486,7 @@
                 filename, True, excluded_filenames, 0,
                 reply_handler=NO_OP,
                 error_handler=NO_OP, timeout=300)
-        except:
+        except UnicodeDecodeError:
             self.log('Could not decode filename: %r' % filename)
         self.running = False
 
@@ -575,7 +575,7 @@
             else:
                 try:
                     excluded_filenames.append(unicode(filename, 'utf-8'))
-                except:
+                except UnicodeDecodeError:
                     self.log('Could not decode filename: %r' % filename)
         filename = song.get_filename()
         try:
@@ -586,7 +586,7 @@
                 filename, True, excluded_filenames, 0,
                 reply_handler=self.analyzed,
                 error_handler=self.error_handler, timeout=300)
-        except:
+        except UnicodeDecodeError:
             self.log('Could not decode filename: %r' % filename)
 
     def process_results(self, results):

=== modified file 'autoqueue/similarity.py'
--- autoqueue/similarity.py	2011-05-03 16:30:52 +0000
+++ autoqueue/similarity.py	2011-05-06 00:06:43 +0000
@@ -1,5 +1,7 @@
 """Autoqueue similarity service."""
 
+# TODO: real logging
+
 import dbus
 import dbus.service
 import gobject
@@ -32,7 +34,7 @@
 DBusGMainLoop(set_as_default=True)
 
 DBUS_BUSNAME = 'org.autoqueue'
-DBUS_IFACE = 'org.autoqueue.SimilarityInterface'
+IFACE = 'org.autoqueue.SimilarityInterface'
 DBUS_PATH = '/org/autoqueue/Similarity'
 
 # If you change even a single character of code, I would ask that you
@@ -86,18 +88,18 @@
 
     def set_path(self, path):
         """Set the database path."""
-        self.path = path
+        self.path = path                # pylint: disable=W0201
 
     def set_queue(self, queue):
         """Set the queue to use."""
-        self.queue = queue
+        self.queue = queue              # pylint: disable=W0201
 
     def run(self):
         connection = sqlite3.connect(
             self.path, timeout=5.0, isolation_level="immediate")
         cursor = connection.cursor()
         while True:
-            priority, cmd = self.queue.get()
+            _, cmd = self.queue.get()
             sql = cmd.sql
             if sql == ('STOP',):
                 cmd.result_queue.put(None)
@@ -108,8 +110,7 @@
             try:
                 cursor.execute(*sql)
             except:
-                for s in sql:
-                    print repr(s)
+                print repr(sql)         # pylint: disable=W0702
             if not sql[0].upper().startswith('SELECT'):
                 commit_needed = True
             for row in cursor.fetchall():
@@ -119,11 +120,10 @@
             cmd.result_queue.put(result)
 
 
-class Db(object):
+class Database(object):
     """Database access class."""
 
     def __init__(self):
-        self._data_dir = None
         self.db_path = os.path.join(
             self.player_get_data_dir(), "similarity.db")
         self.queue = PriorityQueue()
@@ -147,14 +147,11 @@
         Defaults to $XDG_DATA_HOME/autoqueue on Gnome.
 
         """
-        if self._data_dir:
-            return self._data_dir
         if not XDG:
             return NotImplemented
         data_dir = os.path.join(xdg.BaseDirectory.xdg_data_home, 'autoqueue')
         if not os.path.exists(data_dir):
             os.makedirs(data_dir)
-        self._data_dir = data_dir
         return data_dir
 
     def add_track(self, filename, scms, priority):
@@ -257,7 +254,7 @@
         if not exclude_filenames:
             exclude_filenames = []
         to_add = neighbours * 2
-        _ = self.execute_sql(
+        self.execute_sql(
             ("DELETE FROM distance WHERE track_1 = ?;", (trackid,)),
             priority=priority)
         conf = ScmsConfiguration(20)
@@ -302,7 +299,7 @@
             "SELECT * FROM artists WHERE name = ?;", (artist_name,)))
         for row in rows:
             return row
-        _ = self.execute_sql((
+        self.execute_sql((
             "INSERT INTO artists (name) VALUES (?);", (artist_name,)))
         rows = self.execute_sql((
             "SELECT * FROM artists WHERE name = ?;", (artist_name,)))
@@ -318,7 +315,7 @@
             (artist_id, title)), priority=0)
         for row in rows:
             return row
-        _ = self.execute_sql((
+        self.execute_sql((
             "INSERT INTO tracks (artist, title) VALUES (?, ?);",
             (artist_id, title)), priority=0)
         rows = self.execute_sql((
@@ -488,7 +485,8 @@
                 'DELETE FROM artist_2_artist WHERE artist1 = ? OR artist2 = '
                 '?;', (artist_id, artist_id)), priority=10)
             self.execute_sql(
-                ('DELETE FROM artists WHERE id = ?', (artist_id,)), priority=10)
+                ('DELETE FROM artists WHERE id = ?', (artist_id,)),
+                priority=10)
 
 
 class SimilarityService(dbus.service.Object):
@@ -496,7 +494,7 @@
 
     def __init__(self, bus_name, object_path):
         import gst
-        self.db = Db()
+        self.db = Database()
         self.lastfm = True
         self.cache_time = 90
         super(SimilarityService, self).__init__(
@@ -592,22 +590,22 @@
             self.lastfm = False
             return None
 
-    @method(dbus_interface=DBUS_IFACE, in_signature='s')
+    @method(dbus_interface=IFACE, in_signature='s')
     def remove_track_by_filename(self, filename):
         """Remove tracks from database."""
         self.db.remove_track_by_filename(filename)
 
-    @method(dbus_interface=DBUS_IFACE, in_signature='ss')
+    @method(dbus_interface=IFACE, in_signature='ss')
     def remove_track(self, artist, title):
         """Remove tracks from database."""
         self.db.remove_track(artist, title)
 
-    @method(dbus_interface=DBUS_IFACE, in_signature='s')
+    @method(dbus_interface=IFACE, in_signature='s')
     def remove_artist(self, artist):
         """Remove tracks from database."""
         self.db.remove_artist(artist)
 
-    @method(dbus_interface=DBUS_IFACE, in_signature='sbasi')
+    @method(dbus_interface=IFACE, in_signature='sbasi')
     def analyze_track(self, filename, add_neighbours, exclude_filenames,
                       priority):
         """Perform mirage analysis of a track."""
@@ -635,14 +633,13 @@
             trackid, scms, exclude_filenames=exclude_filenames,
             neighbours=NEIGHBOURS, priority=priority)
 
-    @method(dbus_interface=DBUS_IFACE, in_signature='s', out_signature='a(is)')
+    @method(dbus_interface=IFACE, in_signature='s', out_signature='a(is)')
     def get_ordered_mirage_tracks(self, filename):
         """Get similar tracks by mirage acoustic analysis."""
         trackid = self.db.get_track_id(filename, priority=0)
         return self.db.get_neighbours(trackid)
 
-    @method(dbus_interface=DBUS_IFACE, in_signature='ss',
-            out_signature='a(iss)')
+    @method(dbus_interface=IFACE, in_signature='ss', out_signature='a(iss)')
     def get_ordered_similar_tracks(self, artist_name, title):
         """Get similar tracks from last.fm/the database.
 
@@ -663,8 +660,7 @@
         return self.get_similar_tracks_from_lastfm(
             artist_name, title, track_id)
 
-    @method(dbus_interface=DBUS_IFACE, in_signature='as',
-            out_signature='a(is)')
+    @method(dbus_interface=IFACE, in_signature='as', out_signature='a(is)')
     def get_ordered_similar_artists(self, artists):
         """Get similar artists from the database.
 
@@ -694,6 +690,7 @@
         return results
 
     def run(self):
+        """Run loop."""
         self.loop.run()
 
 

=== modified file 'autoqueue/tests/test_autoqueue.py'
--- autoqueue/tests/test_autoqueue.py	2011-05-03 14:47:07 +0000
+++ autoqueue/tests/test_autoqueue.py	2011-05-06 00:06:43 +0000
@@ -1,15 +1,16 @@
 # -*- coding: utf-8 -*-
+"""Tests for autoqueue."""
 import gobject
-import sqlite3
 import unittest
-from datetime import datetime, timedelta
+from datetime import datetime
 from xml.dom import minidom
-from autoqueue import SongBase, AutoQueueBase, Throttle
+from collections import deque
+from autoqueue import SongBase, AutoQueueBase
+
 
 # we have to do this or the tests break badly
 gobject.threads_init()
 
-WAIT_BETWEEN_REQUESTS = timedelta(0,0,10)
 
 FAKE_RESPONSES = {
     'http://ws.audioscrobbler.com/2.0/?method=track.getsimilar&artist='
@@ -31,6 +32,7 @@
 
 
 class FakePlayer(object):
+    """Fake music player object."""
     def __init__(self, plugin_on_song_started):
         self.queue = []
         self.library = [
@@ -56,7 +58,8 @@
         self.plugin_on_song_started = plugin_on_song_started
 
     def satisfies_criteria(self, song, criteria):
-        positions = {'artist':0, 'title':1, 'tags':2}
+        """Check that song satisfies search criteria."""
+        positions = {'artist': 0, 'title': 1, 'tags': 2}
         for criterium in criteria:
             if criterium.startswith('not_'):
                 ncriterium = criterium.split("_")[1]
@@ -67,7 +70,6 @@
                         song[positions[ncriterium]]):
                         return False
                 else:
-                    #print song, criteria
                     if song[positions[ncriterium]] in criteria[criterium]:
                         return False
             else:
@@ -83,12 +85,16 @@
         return True
 
     def play_song_from_queue(self):
+        """Fake playing a song from the queue."""
         func = self.plugin_on_song_started
         queue_song = self.queue.pop(0)
         func(queue_song)
 
 
 class FakeSong(SongBase):
+    """Fake song object."""
+
+    # pylint: disable=W0231
     def __init__(self, artist, title, tags=None, performers=None,
                  filename=None):
         self.filename = filename
@@ -96,6 +102,7 @@
         self.title = title
         self.tags = tags
         self.performers = performers or []
+    # pylint: enable=W0231
 
     def get_artist(self):
         return self.artist.lower()
@@ -127,11 +134,69 @@
         return .5
 
 
+class FakeSimilarityService(object):
+    """Fake similarity Service implementation."""
+
+    def analyze_track(self, filename, add_neighbours, exclude_filenames,
+                      priority, reply_handler=None, error_handler=None,
+                      timeout=0):
+        """Fake analyze."""
+        reply_handler()
+
+    def get_ordered_mirage_tracks(self, filename, reply_handler=None,
+                                  error_handler=None, timeout=0):
+        """Fake get_ordered_mirage_tracks."""
+        reply_handler([])
+
+    def get_ordered_similar_tracks(self, artist_name, title,
+                                   reply_handler=None, error_handler=None,
+                                   timeout=0):
+        """Fake get similar tracks."""
+        reply_handler([(715, 'joanna newsom', 'peach, plum, pear')])
+
+    def last_fm_request(self, url):
+        """Fake last.fm request."""
+        urlfile = FAKE_RESPONSES.get(url)
+        if not urlfile:
+            return None
+        stream = open(urlfile, 'r')
+        try:
+            xmldoc = minidom.parse(stream).documentElement
+            return xmldoc
+        except:  # pylint: disable=W0702
+            return None
+
+
 class FakeAutoQueue(AutoQueueBase):
-    def __init__(self):
+    """Fake autoqueue plugin implementation."""
+
+    def __init__(self):                 # pylint: disable=W0231
         self.connection = None
         self.player = FakePlayer(self.start)
-        super(FakeAutoQueue, self).__init__()
+        self.artist_block_time = 1
+        self._blocked_artists = deque([])
+        self._blocked_artists_times = deque([])
+        self._cache_dir = None
+        self.desired_queue_length = 0
+        self.cached_misses = deque([])
+        self.by_mirage = False
+        self.by_tracks = True
+        self.by_artists = True
+        self.by_tags = True
+        self.running = False
+        self.verbose = False
+        self.weed = False
+        self.song = None
+        self.restrictions = None
+        self.prune_artists = []
+        self.prune_titles = []
+        self.prune_filenames = []
+        self._rows = []
+        self._nrows = []
+        self.last_songs = []
+        self.last_song = None
+        self.found = None
+        self.similarity = FakeSimilarityService()
         self.by_tags = True
         self.verbose = True
 
@@ -139,18 +204,14 @@
         """Simulate song start."""
         self.on_song_started(song)
 
-    def get_db_path(self):
-        return ":memory:"
-
-    def get_database_connection(self):
-        if self.connection:
-            return self.connection
-        self.connection = sqlite3.connect(":memory:")
-        return self.connection
-
-    def close_database_connection(self, connection):
-        """Close the database connection."""
-        pass
+    def block_artist(self, artist_name):
+        """Block songs by artist from being played for a while."""
+        now = datetime.now()
+        self._blocked_artists.append(artist_name)
+        self._blocked_artists_times.append(now)
+        self.log("Blocked artist: %s (%s)" % (
+            artist_name,
+            len(self._blocked_artists)))
 
     def player_construct_file_search(self, filename, restrictions=None):
         """Construct a search that looks for songs with this artist
@@ -205,250 +266,26 @@
         """Return (wrapped) song objects for the songs in the queue."""
         return self.player.queue
 
-    def last_fm_request(self, url):
-        urlfile = FAKE_RESPONSES.get(url)
-        if not urlfile:
-            return None
-        stream = open(urlfile, 'r')
-        try:
-            xmldoc = minidom.parse(stream).documentElement
-            return xmldoc
-        except:
-            return None
-
-    def analyze_track(self, song, add_neighbours=False):
-        yield
-
-
-@Throttle(WAIT_BETWEEN_REQUESTS)
-def throttled_method():
-    return
-
-
-@Throttle(timedelta(0))
-def unthrottled_method():
-    return
-
 
 class TestAutoQueue(unittest.TestCase):
+    """Test autoqueue functionality."""
+
     def setUp(self):
         self.autoqueue = FakeAutoQueue()
 
-    def test_get_database_connection(self):
-        connection = self.autoqueue.get_database_connection()
-        cursor = connection.cursor()
-        cursor.execute("SELECT * FROM tracks;")
-        rows = cursor.fetchall()
-        self.assertEqual([], rows)
-
-    def test_get_artist(self):
-        artist = 'joni mitchell'
-        row = self.autoqueue.get_artist(artist)
-        self.assertEqual((artist, None), row[1:])
-
-    def test_get_track(self):
-        artist = "nina simone"
-        title = "i think it's going to rain today"
-        artist_id = self.autoqueue.get_artist(artist)[0]
-        row = self.autoqueue.get_track(artist, title)
-        self.assertEqual((artist_id, title, None), row[1:])
-
-    def test_get_similar_artists_from_lastfm(self):
-        artist = 'joni mitchell'
-        artist_id = self.autoqueue.get_artist(artist)
-        similar_artists = self.autoqueue.get_similar_artists_from_lastfm(
-            artist, artist_id)
-        td = [
-            {'score': 10000, 'artist': u'rickie lee jones'},
-            {'score': 9271, 'artist': u'carole king'},
-            {'score': 8669, 'artist': u'ani difranco'},
-            {'score': 8127, 'artist': u'joan baez'},
-            {'score': 7473, 'artist': u'neil young'},
-            {'score': 7051, 'artist': u'martha wainwright'},
-            {'score': 7044, 'artist': u'indigo girls'},
-            {'score': 6880, 'artist': u'james taylor'},
-            {'score': 6705, 'artist': u'paul simon'},
-            {'score': 6677, 'artist': u'dar williams'},
-            {'score': 6404, 'artist': u'crosby, stills, nash & young'},
-            {'score': 6229, 'artist': u'k.d. lang'},
-            {'score': 6151, 'artist': u'simon & garfunkel'},
-            {'score': 6064, 'artist': u'joan armatrading'},
-            {'score': 5959, 'artist': u'patty griffin'},
-            {'score': 5883, 'artist': u'leonard cohen'},
-            {'score': 5840, 'artist': u'tim buckley'},
-            {'score': 5702, 'artist': u'suzanne vega'},
-            {'score': 5649, 'artist': u'janis ian'},
-            {'score': 5591, 'artist': u'kate bush'},
-            {'score': 5555, 'artist': u'cat stevens'},
-            {'score': 5477, 'artist': u'neil young & crazy horse'}]
-        sim = [track for track in similar_artists][:22]
-        self.assertEqual(td, sim)
-        artist = u'habib koité & bamada'
-        row = self.autoqueue.get_artist(artist)
-        artist_id = row[0]
-        similar_artists = self.autoqueue.get_similar_artists_from_lastfm(
-            artist, artist_id)
-        sim = [track for track in similar_artists][:22]
-        td = [
-            {'score': 10000, 'artist': u'salif keita'},
-            {'score': 9536, 'artist': u'mamou sidib\xe9'},
-            {'score': 9330, 'artist': u'k\xe9l\xe9tigui diabat\xe9'},
-            {'score': 9058, 'artist': u'ali farka tour\xe9'},
-            {'score': 8917, 'artist': u'habib koit\xe9'},
-            {'score': 8569, 'artist': u'amadou & mariam'},
-            {'score': 5950, 'artist': u'tinariwen'},
-            {'score': 5826, 'artist': u'boubacar traor\xe9'},
-            {'score': 5371, 'artist': u'oliver mtukudzi'},
-            {'score': 381, 'artist': u'super rail band'},
-            {'score': 359, 'artist': u'lobi traor\xe9'},
-            {'score': 358,
-              'artist': u'ali farka tour\xe9 & toumani diabat\xe9'},
-            {'score': 358, 'artist': u'tartit'},
-            {'score': 355, 'artist': u'issa bagayogo'},
-            {'score': 349, 'artist': u'kasse mady diabate'},
-            {'score': 347, 'artist': u'rokia traor\xe9'},
-            {'score': 346, 'artist': u'daby tour\xe9'},
-            {'score': 346, 'artist': u'oumou sangar\xe9'},
-            {'score': 340, 'artist': u'luciana souza'},
-            {'score': 337, 'artist': u'kandia kouyate'},
-            {'score': 326,
-              'artist': u'ali farka tour\xe9 and ry cooder'},
-            {'score': 318, 'artist': u'sali sidibe'}]
-        self.assertEqual(td, sim)
-
-    def test_get_similar_tracks_from_lastfm(self):
-        artist = 'nina simone'
-        title = "i think it's going to rain today"
-        track = self.autoqueue.get_track(artist, title)
-        track_id = track[0]
-        similar_tracks = self.autoqueue.get_similar_tracks_from_lastfm(
-            artist, title, track_id)
-        td = [{'title': u'how long has this been going o',
-                'score': 447, 'artist': u'ella fitzgerald'},
-               {'title': u'our love is here to stay', 'score': 446,
-                'artist': u'dinah washington'},
-               {'title': u'love for sale', 'score': 444,
-                'artist': u'dinah washington'},
-               {'title': u'will i find my love today?', 'score': 443,
-                'artist': u'marlena shaw'},
-               {'title': u'a couple of loosers', 'score': 443,
-                'artist': u'marlena shaw'},
-               {'title': u'reasons', 'score': 438,
-                'artist': u'minnie riperton'},
-               {'title': u'sorry (digitally remastered 02)',
-                'score': 438,
-                'artist': u'natalie cole'},
-               {'title': u'stand by (digitally remastered 02)',
-                'score': 438, 'artist': u'natalie cole'},
-               {'title': u'adventures in paradise', 'score': 436,
-                'artist': u'minnie riperton'},
-               {'title': u"i've got my love to keep me wa", 'score': 436,
-                'artist': u'ella fitzgerald'},
-               {'title': u'find him', 'score': 428,
-                'artist': u'cassandra wilson'},
-               {'title': u'almost like being in love (lp version)',
-                'score': 428, 'artist': u'della reese'},
-               {'title': u'jacaranda bougainvillea', 'score': 426,
-                'artist': u'al jarreau'},
-               {'title': u'mellow mood', 'score': 426,
-                'artist': u'jimmy smith and wes montgomery'}]
-        sim = [track for track in similar_tracks][:14]
-        self.assertEqual(td, sim)
-
-    def test_get_ordered_similar_artists(self):
-        song = FakeSong('nina simone', 'ne me quitte pas')
-        artist = song.get_artist()
-        similar_artists = self.autoqueue.get_ordered_similar_artists(song)
-        td = [
-            {'score': 10000, 'artist': u'billie holiday'},
-            {'score': 7934, 'artist': u'ella fitzgerald'},
-            {'score': 7402, 'artist': u'sarah vaughan'},
-            {'score': 6731, 'artist': u'dinah washington'},
-            {'score': 6518, 'artist': u'madeleine peyroux'},
-            {'score': 6042, 'artist': u'etta james'},
-            {'score': 5065, 'artist': u'peggy lee'},
-            {'score': 4984, 'artist': u'julie london'},
-            {'score': 4905,
-                     'artist': u'ella fitzgerald & louis armstrong'},
-            {'score': 4887, 'artist': u'blossom dearie'}]
-        for i, item in enumerate(td):
-            self.assertEqual(td[i], similar_artists.next())
-        row = self.autoqueue.get_artist(artist)
-        self.assertEqual((artist, None), row[1:])
-        artist = 'dionne warwick'
-        row = self.autoqueue.get_artist(artist)
-        self.assertEqual((artist, None), row[1:])
-
-    def test_get_ordered_similar_tracks(self):
-        song = FakeSong('joni mitchell', 'carey')
-        artist = song.get_artist()
-        title = song.get_title()
-        similar_tracks = self.autoqueue.get_ordered_similar_tracks(song)
-        td = [
-            {'title': u'things behind the sun', 'score': 838,
-             'artist': u'nick drake'},
-            {'title': u'horn', 'score': 807, 'artist': u'nick drake'},
-            {'title': u'peach, plum, pear', 'score': 715,
-             'artist': u'joanna newsom'},
-            {'title': u'suzanne', 'score': 700,
-             'artist': u'leonard cohen'},
-            {'title': u'sprout and the bean', 'score': 691,
-             'artist': u'joanna newsom'},
-            {'title': u"blowin' in the wind", 'score': 664,
-             'artist': u'bob dylan'},
-            {'title': u'famous blue raincoat', 'score': 635,
-             'artist': u'leonard cohen'},
-            {'title': u'song for the asking', 'score': 598,
-             'artist': u'simon & garfunkel'},
-            {'title': u"the times they are a-changin'", 'score': 593,
-             'artist': u'bob dylan'},
-            {'title': u'keep the customer satisfied', 'score': 535,
-             'artist': u'simon & garfunkel'},
-            {'title': u'peace train', 'score': 520,
-             'artist': u'cat stevens'},
-            {'title': u'fire and rain', 'score': 511,
-             'artist': u'james taylor'},
-            {'title': u'enough to be on your way', 'score': 451,
-             'artist': u'james taylor'},
-            {'title': u"that's the spirit", 'score': 449,
-             'artist': u'judee sill'}]
-        sim = [track for track in similar_tracks][:14]
-        self.assertEqual(td, sim)
-        artist_id = self.autoqueue.get_artist(artist)[0]
-        row = self.autoqueue.get_track(artist, title)
-        self.assertEqual((artist_id, title, None), row[1:])
-        artist = 'leonard cohen'
-        title = 'suzanne'
-        artist_id = self.autoqueue.get_artist(artist)[0]
-        row = self.autoqueue.get_track(artist, title)
-        self.assertEqual((artist_id, title, None), row[1:])
-
     def test_queue_needs_songs(self):
+        """Test the queue_needs_songs method."""
         self.autoqueue.desired_queue_length = 4
         self.assertEqual(True, self.autoqueue.queue_needs_songs())
         test_song = FakeSong('Joni Mitchell', 'Carey')
-        for i in range(4):
+        for _ in range(4):
             self.autoqueue.player_enqueue(test_song)
         self.assertEqual(False, self.autoqueue.queue_needs_songs())
 
     def test_on_song_started(self):
+        """Test the on_song_started handler."""
         test_song = FakeSong('Joni Mitchell', 'Carey')
         self.autoqueue.start(test_song)
         songs_in_queue = self.autoqueue.player_get_songs_in_queue()
         self.assertEqual('joanna newsom', songs_in_queue[0].get_artist())
         self.assertEqual('peach, plum, pear', songs_in_queue[0].get_title())
-
-
-class TestThrottle(unittest.TestCase):
-    """Test the throttle decorator."""
-
-    def test_throttle(self):
-        """Test throttling."""
-        now = datetime.now()
-        times = 0
-        while True:
-            throttled_method()
-            times += 1
-            if datetime.now() > (now + timedelta(0, 0, 1000)):
-                break
-        self.assertEqual(True, times < 100)

=== added file 'autoqueue/tests/test_similarity.py'
--- autoqueue/tests/test_similarity.py	1970-01-01 00:00:00 +0000
+++ autoqueue/tests/test_similarity.py	2011-05-06 00:06:43 +0000
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""Tests for autoqueue.similarity."""
+
+import unittest
+from datetime import datetime, timedelta
+from autoqueue.similarity import Throttle, Database
+
+WAIT_BETWEEN_REQUESTS = timedelta(0, 0, 10)
+
+
+@Throttle(WAIT_BETWEEN_REQUESTS)
+def throttled_method():
+    """Dummy method."""
+    return
+
+
+@Throttle(timedelta(0))
+def unthrottled_method():
+    """Dummy method."""
+    return
+
+
+class TestThrottle(unittest.TestCase):
+    """Test the throttle decorator."""
+
+    def test_throttle(self):
+        """Test throttling."""
+        now = datetime.now()
+        times = 0
+        while True:
+            throttled_method()
+            times += 1
+            if datetime.now() > (now + timedelta(0, 0, 1000)):
+                break
+        self.assertEqual(True, times < 100)
+

=== modified file 'mirage/tests/test_mirage.py'
--- mirage/tests/test_mirage.py	2011-05-03 14:42:24 +0000
+++ mirage/tests/test_mirage.py	2011-05-06 00:06:43 +0000
@@ -1,53 +1,42 @@
-import unittest, sqlite3
-from mirage import Mir, Matrix, Db, ScmsConfiguration
+"""Tests for mirage."""
+import unittest
+from mirage import Mir, Matrix, ScmsConfiguration
 from mirage import distance
 from decimal import Decimal, getcontext
 
 import gst
 
-mir = Mir()
+MIR = Mir()
 
-filenames = [
+FILENAMES = [
     'mirage/tests/testfiles/test.mp3',
     'mirage/tests/testfiles/test2.mp3',
     'mirage/tests/testfiles/test3.ogg',
     'mirage/tests/testfiles/test4.ogg',
     'mirage/tests/testfiles/test5.ogg']
 
-scmses = {}
-
-for filename in filenames:
-    scmses[filename] = mir.analyze(filename)
-
-scms = scmses[filenames[0]]
-scms2 = scmses[filenames[1]]
-scms3 = scmses[filenames[2]]
-scms4 = scmses[filenames[3]]
-scms5 = scmses[filenames[4]]
+SCMSES = {}
+
+for filename in FILENAMES:
+    SCMSES[filename] = MIR.analyze(filename)
+
+SCMS = SCMSES[FILENAMES[0]]
+SCMS2 = SCMSES[FILENAMES[1]]
+SCMS3 = SCMSES[FILENAMES[2]]
+SCMS4 = SCMSES[FILENAMES[3]]
+SCMS5 = SCMSES[FILENAMES[4]]
+
 
 def decimize(f):
+    """Convert to decimal."""
     return Decimal(str(f))
 
 
 class TestMir(unittest.TestCase):
-    def setUp(self):
-        connection = sqlite3.connect(":memory:")
-        self.db = Db(":memory:", connection=connection)
-        connection.execute(
-            'CREATE TABLE IF NOT EXISTS mirage (trackid INTEGER PRIMARY KEY, '
-            'filename VARCHAR(300), scms BLOB)')
-        connection.execute(
-            "CREATE TABLE IF NOT EXISTS distance (track_1 INTEGER, track_2 "
-            "INTEGER, distance INTEGER)")
-        connection.execute(
-            "CREATE INDEX IF NOT EXISTS mfnx ON mirage (filename)")
-        connection.execute(
-            "CREATE INDEX IF NOT EXISTS dtrack1x ON distance (track_1)")
-        connection.execute(
-            "CREATE INDEX IF NOT EXISTS dtrack2x ON distance (track_2)")
-        connection.commit()
+    """Test mirage analysis and comparison."""
 
     def test_matrix(self):
+        """Test the matrix object."""
         getcontext().prec = 6
         mat = Matrix(8, 5)
         for i in range(mat.rows):
@@ -65,6 +54,7 @@
              0.875, 1.0, 1.125, 1.25, 1.375]])
 
     def test_multiply(self):
+        """Test matrix multiplication."""
         getcontext().prec = 6
         mat = Matrix(8, 5)
         for i in range(mat.rows):
@@ -88,81 +78,35 @@
              0.0, 2.3375, 4.675, 7.0125]])
 
     def test_analysis(self):
-        c = ScmsConfiguration(20)
-
-        self.assertEqual(0, int(distance(scms, scms, c)))
-        self.assertEqual(75, int(distance(scms, scms2, c)))
-        self.assertEqual(52, int(distance(scms, scms3, c)))
-        self.assertEqual(69, int(distance(scms, scms4, c)))
-        self.assertEqual(240, int(distance(scms, scms5, c)))
-
-        self.assertEqual(75, int(distance(scms2, scms, c)))
-        self.assertEqual(0, int(distance(scms2, scms2, c)))
-        self.assertEqual(16, int(distance(scms2, scms3, c)))
-        self.assertEqual(59, int(distance(scms2, scms4, c)))
-        self.assertEqual(124, int(distance(scms2, scms5, c)))
-
-        self.assertEqual(52, int(distance(scms3, scms, c)))
-        self.assertEqual(16, int(distance(scms3, scms2, c)))
-        self.assertEqual(0, int(distance(scms3, scms3, c)))
-        self.assertEqual(49, int(distance(scms3, scms4, c)))
-        self.assertEqual(84, int(distance(scms3, scms5, c)))
-
-        self.assertEqual(69, int(distance(scms4, scms, c)))
-        self.assertEqual(59, int(distance(scms4, scms2, c)))
-        self.assertEqual(49, int(distance(scms4, scms3, c)))
-        self.assertEqual(0, int(distance(scms4, scms4, c)))
-        self.assertEqual(124, int(distance(scms4, scms5, c)))
-
-        self.assertEqual(240, int(distance(scms5, scms, c)))
-        self.assertEqual(124, int(distance(scms5, scms2, c)))
-        self.assertEqual(84, int(distance(scms5, scms3, c)))
-        self.assertEqual(124, int(distance(scms5, scms4, c)))
-        self.assertEqual(0, int(distance(scms5, scms5, c)))
-
-    def test_add_track(self):
-        for filename in filenames:
-            self.db.add_track(filename, scmses[filename])
-        self.assertEqual(
-            [1,2,3,4,5],
-            sorted([id for (scms, id) in
-                    self.db.get_tracks()]))
-        self.assertEqual(
-            [1,2,5],
-            sorted([id for (scms, id) in
-                    self.db.get_tracks(exclude_ids=['3','4'])]))
-
-    def test_get_track(self):
-        for filename in filenames:
-            self.db.add_track(filename, scmses[filename])
-        scms3_db = self.db.get_track(filenames[2])[1]
-        scms4_db = self.db.get_track(filenames[3])[1]
-        c = ScmsConfiguration(20)
-        self.assertEqual(49, int(distance(scms3_db, scms4_db, c)))
-
-    def test_add_neighbours(self):
-        for filename in filenames:
-            testscms = scmses[filename]
-            self.db.add_track(filename, testscms)
-            track_id = self.db.get_track_id(filename)
-            for dummy in self.db.add_neighbours(track_id, testscms):
-                pass
-        connection = self.db.get_database_connection()
-        distances = [
-            row for row in connection.execute("SELECT * FROM distance")]
-        self.assertEqual(
-            [(2, 1, 75208), (3, 1, 52895), (3, 2, 16559), (4, 1, 69194),
-             (4, 2, 59488), (4, 3, 49652), (5, 1, 240408), (5, 4, 124490),
-             (5, 2, 124272), (5, 3, 84228)],
-            distances)
-
-    def test_get_neighbours(self):
-        for filename in filenames:
-            testscms = scmses[filename]
-            self.db.add_track(filename, testscms)
-            track_id = self.db.get_track_id(filename)
-            for dummy in self.db.add_neighbours(track_id, testscms):
-                pass
-        self.assertEqual(
-            [(84228, 3), (124272, 2), (124490, 4), (240408, 1)],
-            [a for a in self.db.get_neighbours(5)])
+        """Test mirage analysis."""
+        conf = ScmsConfiguration(20)
+
+        self.assertEqual(0, int(distance(SCMS, SCMS, conf)))
+        self.assertEqual(75, int(distance(SCMS, SCMS2, conf)))
+        self.assertEqual(52, int(distance(SCMS, SCMS3, conf)))
+        self.assertEqual(69, int(distance(SCMS, SCMS4, conf)))
+        self.assertEqual(240, int(distance(SCMS, SCMS5, conf)))
+
+        self.assertEqual(75, int(distance(SCMS2, SCMS, conf)))
+        self.assertEqual(0, int(distance(SCMS2, SCMS2, conf)))
+        self.assertEqual(16, int(distance(SCMS2, SCMS3, conf)))
+        self.assertEqual(59, int(distance(SCMS2, SCMS4, conf)))
+        self.assertEqual(124, int(distance(SCMS2, SCMS5, conf)))
+
+        self.assertEqual(52, int(distance(SCMS3, SCMS, conf)))
+        self.assertEqual(16, int(distance(SCMS3, SCMS2, conf)))
+        self.assertEqual(0, int(distance(SCMS3, SCMS3, conf)))
+        self.assertEqual(49, int(distance(SCMS3, SCMS4, conf)))
+        self.assertEqual(84, int(distance(SCMS3, SCMS5, conf)))
+
+        self.assertEqual(69, int(distance(SCMS4, SCMS, conf)))
+        self.assertEqual(59, int(distance(SCMS4, SCMS2, conf)))
+        self.assertEqual(49, int(distance(SCMS4, SCMS3, conf)))
+        self.assertEqual(0, int(distance(SCMS4, SCMS4, conf)))
+        self.assertEqual(124, int(distance(SCMS4, SCMS5, conf)))
+
+        self.assertEqual(240, int(distance(SCMS5, SCMS, conf)))
+        self.assertEqual(124, int(distance(SCMS5, SCMS2, conf)))
+        self.assertEqual(84, int(distance(SCMS5, SCMS3, conf)))
+        self.assertEqual(124, int(distance(SCMS5, SCMS4, conf)))
+        self.assertEqual(0, int(distance(SCMS5, SCMS5, conf)))