diff --git a/test/test_sort.py b/test/test_sort.py
index dc4e6d2b2..7dadbcf79 100644
--- a/test/test_sort.py
+++ b/test/test_sort.py
@@ -15,8 +15,7 @@
 
 """Various tests for querying the library database.
 """
-from __future__ import (division, absolute_import, print_function,
-                        unicode_literals)
+from __future__ import (division, absolute_import, print_function)
 
 from test import _common
 from test._common import unittest
@@ -33,71 +32,71 @@ class DummyDataTestCase(_common.TestCase):
         self.lib = beets.library.Library(':memory:')
 
         albums = [_common.album() for _ in range(3)]
-        albums[0].album = "Album A"
-        albums[0].genre = "Rock"
+        albums[0].album = u"Album A"
+        albums[0].genre = u"Rock"
         albums[0].year = 2001
-        albums[0].flex1 = "Flex1-1"
-        albums[0].flex2 = "Flex2-A"
-        albums[0].albumartist = "Foo"
+        albums[0].flex1 = u"Flex1-1"
+        albums[0].flex2 = u"Flex2-A"
+        albums[0].albumartist = u"Foo"
         albums[0].albumartist_sort = None
-        albums[1].album = "Album B"
-        albums[1].genre = "Rock"
+        albums[1].album = u"Album B"
+        albums[1].genre = u"Rock"
         albums[1].year = 2001
-        albums[1].flex1 = "Flex1-2"
-        albums[1].flex2 = "Flex2-A"
-        albums[1].albumartist = "Bar"
+        albums[1].flex1 = u"Flex1-2"
+        albums[1].flex2 = u"Flex2-A"
+        albums[1].albumartist = u"Bar"
         albums[1].albumartist_sort = None
-        albums[2].album = "Album C"
-        albums[2].genre = "Jazz"
+        albums[2].album = u"Album C"
+        albums[2].genre = u"Jazz"
         albums[2].year = 2005
-        albums[2].flex1 = "Flex1-1"
-        albums[2].flex2 = "Flex2-B"
-        albums[2].albumartist = "Baz"
+        albums[2].flex1 = u"Flex1-1"
+        albums[2].flex2 = u"Flex2-B"
+        albums[2].albumartist = u"Baz"
         albums[2].albumartist_sort = None
         for album in albums:
             self.lib.add(album)
 
         items = [_common.item() for _ in range(4)]
-        items[0].title = 'Foo bar'
-        items[0].artist = 'One'
-        items[0].album = 'Baz'
+        items[0].title = u'Foo bar'
+        items[0].artist = u'One'
+        items[0].album = u'Baz'
         items[0].year = 2001
         items[0].comp = True
-        items[0].flex1 = "Flex1-0"
-        items[0].flex2 = "Flex2-A"
+        items[0].flex1 = u"Flex1-0"
+        items[0].flex2 = u"Flex2-A"
         items[0].album_id = albums[0].id
         items[0].artist_sort = None
         items[0].path = "/path0.mp3"
         items[0].track = 1
-        items[1].title = 'Baz qux'
-        items[1].artist = 'Two'
-        items[1].album = 'Baz'
+        items[1].title = u'Baz qux'
+        items[1].artist = u'Two'
+        items[1].album = u'Baz'
         items[1].year = 2002
         items[1].comp = True
-        items[1].flex1 = "Flex1-1"
-        items[1].flex2 = "Flex2-A"
+        items[1].flex1 = u"Flex1-1"
+        items[1].flex2 = u"Flex2-A"
         items[1].album_id = albums[0].id
         items[1].artist_sort = None
         items[1].path = "/patH1.mp3"
         items[1].track = 2
-        items[2].title = 'Beets 4 eva'
-        items[2].artist = 'Three'
-        items[2].album = 'Foo'
+        items[2].title = u'Beets 4 eva'
+        items[2].artist = u'Three'
+        items[2].album = u'Foo'
         items[2].year = 2003
         items[2].comp = False
-        items[2].flex1 = "Flex1-2"
-        items[2].flex2 = "Flex1-B"
+        items[2].flex1 = u"Flex1-2"
+        items[2].flex2 = u"Flex1-B"
         items[2].album_id = albums[1].id
         items[2].artist_sort = None
         items[2].path = "/paTH2.mp3"
         items[2].track = 3
-        items[3].title = 'Beets 4 eva'
-        items[3].artist = 'Three'
-        items[3].album = 'Foo2'
+        items[3].title = u'Beets 4 eva'
+        items[3].artist = u'Three'
+        items[3].album = u'Foo2'
         items[3].year = 2004
         items[3].comp = False
-        items[3].flex1 = "Flex1-2"
-        items[3].flex2 = "Flex1-C"
+        items[3].flex1 = u"Flex1-2"
+        items[3].flex2 = u"Flex1-C"
         items[3].album_id = albums[2].id
         items[3].artist_sort = None
         items[3].path = "/PATH3.mp3"
@@ -108,50 +107,50 @@ class DummyDataTestCase(_common.TestCase):
 
 class SortFixedFieldTest(DummyDataTestCase):
     def test_sort_asc(self):
-        q = ''
-        sort = dbcore.query.FixedFieldSort("year", True)
+        q = u''
+        sort = dbcore.query.FixedFieldSort(u"year", True)
         results = self.lib.items(q, sort)
         self.assertLessEqual(results[0]['year'], results[1]['year'])
         self.assertEqual(results[0]['year'], 2001)
         # same thing with query string
-        q = 'year+'
+        q = u'year+'
         results2 = self.lib.items(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_desc(self):
-        q = ''
-        sort = dbcore.query.FixedFieldSort("year", False)
+        q = u''
+        sort = dbcore.query.FixedFieldSort(u"year", False)
         results = self.lib.items(q, sort)
         self.assertGreaterEqual(results[0]['year'], results[1]['year'])
         self.assertEqual(results[0]['year'], 2004)
         # same thing with query string
-        q = 'year-'
+        q = u'year-'
         results2 = self.lib.items(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_two_field_asc(self):
-        q = ''
-        s1 = dbcore.query.FixedFieldSort("album", True)
-        s2 = dbcore.query.FixedFieldSort("year", True)
+        q = u''
+        s1 = dbcore.query.FixedFieldSort(u"album", True)
+        s2 = dbcore.query.FixedFieldSort(u"year", True)
         sort = dbcore.query.MultipleSort()
         sort.add_sort(s1)
         sort.add_sort(s2)
         results = self.lib.items(q, sort)
         self.assertLessEqual(results[0]['album'], results[1]['album'])
         self.assertLessEqual(results[1]['album'], results[2]['album'])
-        self.assertEqual(results[0]['album'], 'Baz')
-        self.assertEqual(results[1]['album'], 'Baz')
+        self.assertEqual(results[0]['album'], u'Baz')
+        self.assertEqual(results[1]['album'], u'Baz')
         self.assertLessEqual(results[0]['year'], results[1]['year'])
         # same thing with query string
-        q = 'album+ year+'
+        q = u'album+ year+'
         results2 = self.lib.items(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_path_field(self):
-        q = ''
+        q = u''
         sort = dbcore.query.FixedFieldSort('path', True)
         results = self.lib.items(q, sort)
         self.assertEqual(results[0]['path'], '/path0.mp3')
@@ -162,46 +161,46 @@ class SortFixedFieldTest(DummyDataTestCase):
 
 class SortFlexFieldTest(DummyDataTestCase):
     def test_sort_asc(self):
-        q = ''
-        sort = dbcore.query.SlowFieldSort("flex1", True)
+        q = u''
+        sort = dbcore.query.SlowFieldSort(u"flex1", True)
         results = self.lib.items(q, sort)
         self.assertLessEqual(results[0]['flex1'], results[1]['flex1'])
-        self.assertEqual(results[0]['flex1'], 'Flex1-0')
+        self.assertEqual(results[0]['flex1'], u'Flex1-0')
         # same thing with query string
-        q = 'flex1+'
+        q = u'flex1+'
         results2 = self.lib.items(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_desc(self):
-        q = ''
-        sort = dbcore.query.SlowFieldSort("flex1", False)
+        q = u''
+        sort = dbcore.query.SlowFieldSort(u"flex1", False)
         results = self.lib.items(q, sort)
         self.assertGreaterEqual(results[0]['flex1'], results[1]['flex1'])
         self.assertGreaterEqual(results[1]['flex1'], results[2]['flex1'])
         self.assertGreaterEqual(results[2]['flex1'], results[3]['flex1'])
-        self.assertEqual(results[0]['flex1'], 'Flex1-2')
+        self.assertEqual(results[0]['flex1'], u'Flex1-2')
         # same thing with query string
-        q = 'flex1-'
+        q = u'flex1-'
         results2 = self.lib.items(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_two_field(self):
-        q = ''
-        s1 = dbcore.query.SlowFieldSort("flex2", False)
-        s2 = dbcore.query.SlowFieldSort("flex1", True)
+        q = u''
+        s1 = dbcore.query.SlowFieldSort(u"flex2", False)
+        s2 = dbcore.query.SlowFieldSort(u"flex1", True)
         sort = dbcore.query.MultipleSort()
         sort.add_sort(s1)
         sort.add_sort(s2)
         results = self.lib.items(q, sort)
         self.assertGreaterEqual(results[0]['flex2'], results[1]['flex2'])
         self.assertGreaterEqual(results[1]['flex2'], results[2]['flex2'])
-        self.assertEqual(results[0]['flex2'], 'Flex2-A')
-        self.assertEqual(results[1]['flex2'], 'Flex2-A')
+        self.assertEqual(results[0]['flex2'], u'Flex2-A')
+        self.assertEqual(results[1]['flex2'], u'Flex2-A')
         self.assertLessEqual(results[0]['flex1'], results[1]['flex1'])
         # same thing with query string
-        q = 'flex2- flex1+'
+        q = u'flex2- flex1+'
         results2 = self.lib.items(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
@@ -209,44 +208,44 @@ class SortFlexFieldTest(DummyDataTestCase):
 
 class SortAlbumFixedFieldTest(DummyDataTestCase):
     def test_sort_asc(self):
-        q = ''
-        sort = dbcore.query.FixedFieldSort("year", True)
+        q = u''
+        sort = dbcore.query.FixedFieldSort(u"year", True)
         results = self.lib.albums(q, sort)
         self.assertLessEqual(results[0]['year'], results[1]['year'])
         self.assertEqual(results[0]['year'], 2001)
         # same thing with query string
-        q = 'year+'
+        q = u'year+'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_desc(self):
-        q = ''
-        sort = dbcore.query.FixedFieldSort("year", False)
+        q = u''
+        sort = dbcore.query.FixedFieldSort(u"year", False)
         results = self.lib.albums(q, sort)
         self.assertGreaterEqual(results[0]['year'], results[1]['year'])
         self.assertEqual(results[0]['year'], 2005)
         # same thing with query string
-        q = 'year-'
+        q = u'year-'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_two_field_asc(self):
-        q = ''
-        s1 = dbcore.query.FixedFieldSort("genre", True)
-        s2 = dbcore.query.FixedFieldSort("album", True)
+        q = u''
+        s1 = dbcore.query.FixedFieldSort(u"genre", True)
+        s2 = dbcore.query.FixedFieldSort(u"album", True)
         sort = dbcore.query.MultipleSort()
         sort.add_sort(s1)
         sort.add_sort(s2)
         results = self.lib.albums(q, sort)
         self.assertLessEqual(results[0]['genre'], results[1]['genre'])
         self.assertLessEqual(results[1]['genre'], results[2]['genre'])
-        self.assertEqual(results[1]['genre'], 'Rock')
-        self.assertEqual(results[2]['genre'], 'Rock')
+        self.assertEqual(results[1]['genre'], u'Rock')
+        self.assertEqual(results[2]['genre'], u'Rock')
         self.assertLessEqual(results[1]['album'], results[2]['album'])
         # same thing with query string
-        q = 'genre+ album+'
+        q = u'genre+ album+'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
@@ -254,44 +253,44 @@ class SortAlbumFixedFieldTest(DummyDataTestCase):
 
 class SortAlbumFlexFieldTest(DummyDataTestCase):
     def test_sort_asc(self):
-        q = ''
-        sort = dbcore.query.SlowFieldSort("flex1", True)
+        q = u''
+        sort = dbcore.query.SlowFieldSort(u"flex1", True)
         results = self.lib.albums(q, sort)
         self.assertLessEqual(results[0]['flex1'], results[1]['flex1'])
         self.assertLessEqual(results[1]['flex1'], results[2]['flex1'])
         # same thing with query string
-        q = 'flex1+'
+        q = u'flex1+'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_desc(self):
-        q = ''
-        sort = dbcore.query.SlowFieldSort("flex1", False)
+        q = u''
+        sort = dbcore.query.SlowFieldSort(u"flex1", False)
         results = self.lib.albums(q, sort)
         self.assertGreaterEqual(results[0]['flex1'], results[1]['flex1'])
         self.assertGreaterEqual(results[1]['flex1'], results[2]['flex1'])
         # same thing with query string
-        q = 'flex1-'
+        q = u'flex1-'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_two_field_asc(self):
-        q = ''
-        s1 = dbcore.query.SlowFieldSort("flex2", True)
-        s2 = dbcore.query.SlowFieldSort("flex1", True)
+        q = u''
+        s1 = dbcore.query.SlowFieldSort(u"flex2", True)
+        s2 = dbcore.query.SlowFieldSort(u"flex1", True)
         sort = dbcore.query.MultipleSort()
         sort.add_sort(s1)
         sort.add_sort(s2)
         results = self.lib.albums(q, sort)
         self.assertLessEqual(results[0]['flex2'], results[1]['flex2'])
         self.assertLessEqual(results[1]['flex2'], results[2]['flex2'])
-        self.assertEqual(results[0]['flex2'], 'Flex2-A')
-        self.assertEqual(results[1]['flex2'], 'Flex2-A')
+        self.assertEqual(results[0]['flex2'], u'Flex2-A')
+        self.assertEqual(results[1]['flex2'], u'Flex2-A')
         self.assertLessEqual(results[0]['flex1'], results[1]['flex1'])
         # same thing with query string
-        q = 'flex2+ flex1+'
+        q = u'flex2+ flex1+'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
@@ -299,25 +298,25 @@ class SortAlbumFlexFieldTest(DummyDataTestCase):
 
 class SortAlbumComputedFieldTest(DummyDataTestCase):
     def test_sort_asc(self):
-        q = ''
-        sort = dbcore.query.SlowFieldSort("path", True)
+        q = u''
+        sort = dbcore.query.SlowFieldSort(u"path", True)
         results = self.lib.albums(q, sort)
         self.assertLessEqual(results[0]['path'], results[1]['path'])
         self.assertLessEqual(results[1]['path'], results[2]['path'])
         # same thing with query string
-        q = 'path+'
+        q = u'path+'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_sort_desc(self):
-        q = ''
-        sort = dbcore.query.SlowFieldSort("path", False)
+        q = u''
+        sort = dbcore.query.SlowFieldSort(u"path", False)
         results = self.lib.albums(q, sort)
         self.assertGreaterEqual(results[0]['path'], results[1]['path'])
         self.assertGreaterEqual(results[1]['path'], results[2]['path'])
         # same thing with query string
-        q = 'path-'
+        q = u'path-'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
@@ -325,24 +324,24 @@ class SortAlbumComputedFieldTest(DummyDataTestCase):
 
 class SortCombinedFieldTest(DummyDataTestCase):
     def test_computed_first(self):
-        q = ''
-        s1 = dbcore.query.SlowFieldSort("path", True)
-        s2 = dbcore.query.FixedFieldSort("year", True)
+        q = u''
+        s1 = dbcore.query.SlowFieldSort(u"path", True)
+        s2 = dbcore.query.FixedFieldSort(u"year", True)
         sort = dbcore.query.MultipleSort()
         sort.add_sort(s1)
         sort.add_sort(s2)
         results = self.lib.albums(q, sort)
         self.assertLessEqual(results[0]['path'], results[1]['path'])
         self.assertLessEqual(results[1]['path'], results[2]['path'])
-        q = 'path+ year+'
+        q = u'path+ year+'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
 
     def test_computed_second(self):
-        q = ''
-        s1 = dbcore.query.FixedFieldSort("year", True)
-        s2 = dbcore.query.SlowFieldSort("path", True)
+        q = u''
+        s1 = dbcore.query.FixedFieldSort(u"year", True)
+        s2 = dbcore.query.SlowFieldSort(u"path", True)
         sort = dbcore.query.MultipleSort()
         sort.add_sort(s1)
         sort.add_sort(s2)
@@ -350,7 +349,7 @@ class SortCombinedFieldTest(DummyDataTestCase):
         self.assertLessEqual(results[0]['year'], results[1]['year'])
         self.assertLessEqual(results[1]['year'], results[2]['year'])
         self.assertLessEqual(results[0]['path'], results[1]['path'])
-        q = 'year+ path+'
+        q = u'year+ path+'
         results2 = self.lib.albums(q)
         for r1, r2 in zip(results, results2):
             self.assertEqual(r1.id, r2.id)
@@ -385,23 +384,23 @@ class CaseSensitivityTest(DummyDataTestCase, _common.TestCase):
         super(CaseSensitivityTest, self).setUp()
 
         album = _common.album()
-        album.album = "album"
-        album.genre = "alternative"
-        album.year = "2001"
-        album.flex1 = "flex1"
-        album.flex2 = "flex2-A"
-        album.albumartist = "bar"
+        album.album = u"album"
+        album.genre = u"alternative"
+        album.year = u"2001"
+        album.flex1 = u"flex1"
+        album.flex2 = u"flex2-A"
+        album.albumartist = u"bar"
         album.albumartist_sort = None
         self.lib.add(album)
 
         item = _common.item()
-        item.title = 'another'
-        item.artist = 'lowercase'
-        item.album = 'album'
+        item.title = u'another'
+        item.artist = u'lowercase'
+        item.album = u'album'
         item.year = 2001
         item.comp = True
-        item.flex1 = "flex1"
-        item.flex2 = "flex2-A"
+        item.flex1 = u"flex1"
+        item.flex2 = u"flex2-A"
         item.album_id = album.id
         item.artist_sort = None
         item.track = 10
@@ -417,49 +416,49 @@ class CaseSensitivityTest(DummyDataTestCase, _common.TestCase):
 
     def test_smart_artist_case_insensitive(self):
         config['sort_case_insensitive'] = True
-        q = 'artist+'
+        q = u'artist+'
         results = list(self.lib.items(q))
-        self.assertEqual(results[0].artist, 'lowercase')
-        self.assertEqual(results[1].artist, 'One')
+        self.assertEqual(results[0].artist, u'lowercase')
+        self.assertEqual(results[1].artist, u'One')
 
     def test_smart_artist_case_sensitive(self):
         config['sort_case_insensitive'] = False
-        q = 'artist+'
+        q = u'artist+'
         results = list(self.lib.items(q))
-        self.assertEqual(results[0].artist, 'One')
-        self.assertEqual(results[-1].artist, 'lowercase')
+        self.assertEqual(results[0].artist, u'One')
+        self.assertEqual(results[-1].artist, u'lowercase')
 
     def test_fixed_field_case_insensitive(self):
         config['sort_case_insensitive'] = True
-        q = 'album+'
+        q = u'album+'
         results = list(self.lib.albums(q))
-        self.assertEqual(results[0].album, 'album')
-        self.assertEqual(results[1].album, 'Album A')
+        self.assertEqual(results[0].album, u'album')
+        self.assertEqual(results[1].album, u'Album A')
 
     def test_fixed_field_case_sensitive(self):
         config['sort_case_insensitive'] = False
-        q = 'album+'
+        q = u'album+'
         results = list(self.lib.albums(q))
-        self.assertEqual(results[0].album, 'Album A')
-        self.assertEqual(results[-1].album, 'album')
+        self.assertEqual(results[0].album, u'Album A')
+        self.assertEqual(results[-1].album, u'album')
 
     def test_flex_field_case_insensitive(self):
         config['sort_case_insensitive'] = True
-        q = 'flex1+'
+        q = u'flex1+'
         results = list(self.lib.items(q))
-        self.assertEqual(results[0].flex1, 'flex1')
-        self.assertEqual(results[1].flex1, 'Flex1-0')
+        self.assertEqual(results[0].flex1, u'flex1')
+        self.assertEqual(results[1].flex1, u'Flex1-0')
 
     def test_flex_field_case_sensitive(self):
         config['sort_case_insensitive'] = False
-        q = 'flex1+'
+        q = u'flex1+'
         results = list(self.lib.items(q))
-        self.assertEqual(results[0].flex1, 'Flex1-0')
-        self.assertEqual(results[-1].flex1, 'flex1')
+        self.assertEqual(results[0].flex1, u'Flex1-0')
+        self.assertEqual(results[-1].flex1, u'flex1')
 
     def test_case_sensitive_only_affects_text(self):
         config['sort_case_insensitive'] = True
-        q = 'track+'
+        q = u'track+'
         results = list(self.lib.items(q))
         # If the numerical values were sorted as strings,
         # then ['1', '10', '2'] would be valid.
@@ -473,9 +472,10 @@ class NonExistingFieldTest(DummyDataTestCase):
     """Test sorting by non-existing fields"""
 
     def test_non_existing_fields_not_fail(self):
-        qs = ['foo+', 'foo-', '--', '-+', '+-', '++', '-foo-', '-foo+', '---']
+        qs = [u'foo+', u'foo-', u'--', u'-+', u'+-',
+              u'++', u'-foo-', u'-foo+', u'---']
 
-        q0 = 'foo+'
+        q0 = u'foo+'
         results0 = list(self.lib.items(q0))
         for q1 in qs:
             results1 = list(self.lib.items(q1))
@@ -483,16 +483,16 @@ class NonExistingFieldTest(DummyDataTestCase):
                 self.assertEqual(r1.id, r2.id)
 
     def test_combined_non_existing_field_asc(self):
-        all_results = list(self.lib.items('id+'))
-        q = 'foo+ id+'
+        all_results = list(self.lib.items(u'id+'))
+        q = u'foo+ id+'
         results = list(self.lib.items(q))
         self.assertEqual(len(all_results), len(results))
         for r1, r2 in zip(all_results, results):
             self.assertEqual(r1.id, r2.id)
 
     def test_combined_non_existing_field_desc(self):
-        all_results = list(self.lib.items('id+'))
-        q = 'foo- id+'
+        all_results = list(self.lib.items(u'id+'))
+        q = u'foo- id+'
         results = list(self.lib.items(q))
         self.assertEqual(len(all_results), len(results))
         for r1, r2 in zip(all_results, results):
@@ -501,18 +501,18 @@ class NonExistingFieldTest(DummyDataTestCase):
     def test_field_present_in_some_items(self):
         """Test ordering by a field not present on all items."""
         # append 'foo' to two to items (1,2)
-        items = self.lib.items('id+')
+        items = self.lib.items(u'id+')
         ids = [i.id for i in items]
-        items[1].foo = 'bar1'
-        items[2].foo = 'bar2'
+        items[1].foo = u'bar1'
+        items[2].foo = u'bar2'
         items[1].store()
         items[2].store()
 
-        results_asc = list(self.lib.items('foo+ id+'))
+        results_asc = list(self.lib.items(u'foo+ id+'))
         self.assertEqual([i.id for i in results_asc],
                          # items without field first
                          [ids[0], ids[3], ids[1], ids[2]])
-        results_desc = list(self.lib.items('foo- id+'))
+        results_desc = list(self.lib.items(u'foo- id+'))
         self.assertEqual([i.id for i in results_desc],
                          # items without field last
                          [ids[2], ids[1], ids[0], ids[3]])
@@ -523,13 +523,13 @@ class NonExistingFieldTest(DummyDataTestCase):
         If a string ends with a sorting suffix, it takes precedence over the
         NotQuery parsing.
         """
-        query, sort = beets.library.parse_query_string('-bar+',
+        query, sort = beets.library.parse_query_string(u'-bar+',
                                                        beets.library.Item)
         self.assertEqual(len(query.subqueries), 1)
         self.assertTrue(isinstance(query.subqueries[0],
                                    dbcore.query.TrueQuery))
         self.assertTrue(isinstance(sort, dbcore.query.SlowFieldSort))
-        self.assertEqual(sort.field, '-bar')
+        self.assertEqual(sort.field, u'-bar')
 
 
 def suite():