def main():
parser = optparse.OptionParser(usage='%prog')
parser.add_option('--clear-datastore', action='store_true')
(options, args) = parser.parse_args()
startup_appengine(clear_datastore=options.clear_datastore)
from djdb import search, models
import datetime
idx = search.Indexer()
# Create some test artists.
art1 = models.Artist(name=u"Fall, The",
parent=idx.transaction,
key_name="art1")
art2 = models.Artist(name=u"Eno, Brian",
parent=idx.transaction,
key_name="art2")
# Create some test albums.
alb1 = models.Album(title=u"This Nation's Saving Grace",
album_id=12345,
import_timestamp=datetime.datetime.now(),
album_artist=art1,
num_tracks=123,
parent=idx.transaction)
alb2 = models.Album(title=u"Another Green World",
album_id=67890,
import_timestamp=datetime.datetime.now(),
album_artist=art2,
num_tracks=456,
parent=idx.transaction)
for i, track_title in enumerate(
(u"Spider And I", u"Running To Tie Your Shoes", u"Kings Lead Hat")):
idx.add_track(
models.Track(ufid="test3-%d" % i,
album=alb2,
sampling_rate_hz=44110,
bit_rate_kbps=128,
channels="mono",
duration_ms=789,
title=track_title,
track_artist=art2,
track_num=i + 1,
parent=idx.transaction))
idx.add_artist(art1)
idx.add_artist(art2)
idx.add_album(alb1)
idx.add_album(alb2)
idx.save() # saves all objects
print "created some artists and stuff"
def setUp(self):
idx = search.Indexer()
# Create some test artists.
art = models.Artist(name=u"beatles",
parent=idx.transaction,
key_name="ss-art1")
idx.add_artist(art)
art = models.Artist(name=u"beatnicks",
parent=idx.transaction,
key_name="ss-art2")
idx.add_artist(art)
art = models.Artist(name=u"beatnuts",
parent=idx.transaction,
key_name="ss-art3")
idx.add_artist(art)
idx.save()
def setUp(self):
# Get user.
self.client = Client()
self.user = models.User.all().filter('email =', '*****@*****.**')[0]
# Create a test artist and album.
self.artist = models.Artist(name=u"Test Artist")
self.artist.save()
self.album = models.Album(title='test album',
album_id=12345,
import_timestamp=datetime.datetime.now(),
album_artist=self.artist,
num_tracks=7)
self.album.save()
def test_track(self):
# Check key generation against a known case.
self.assertEqual(u"djdb/t:test ufid",
models.Track.get_key_name("test ufid"))
alb = models.Album(title='test album',
album_id=12345,
import_timestamp=datetime.datetime.now(),
album_artist=self.test_artist,
current_tags=[u"zap", u"explicit", u"foo"],
num_tracks=13)
trk = models.Track(ufid="test ufid",
album=alb,
sampling_rate_hz=44100,
bit_rate_kbps=320,
channels='stereo',
duration_ms=123456,
title="test track",
current_tags=[u"zap", u"explicit", u"foo"],
track_num=4)
# Check that the ufid property works properly.
self.assertEqual("test ufid", trk.ufid)
# Our human-readable duration is truncated to the nearest second.
self.assertEqual("2:03", trk.duration)
# Check that the artist_name property works when no track_artist
# has been set.
self.assertEqual(self.test_artist.name, trk.artist_name)
# Check that the unicode representation of the object is the track
# name.
self.assertEqual("test track", unicode(trk))
# Check that tag-related things work.
for obj in (alb, trk):
self.assertEqual([u"explicit", u"foo", u"zap"],
obj.sorted_current_tags)
self.assertTrue(trk.is_explicit)
trk.current_tags = [u"foo"]
self.assertFalse(trk.is_explicit)
# Set a separate artist for this track, then check that the
# artist_name property still works.
trk_art = models.Artist(name='Track Artist')
trk_art.save()
trk.track_artist = trk_art
self.assertEqual(trk.track_artist.name, trk.artist_name)
def test_album_sorted_tracks(self):
art = models.Artist(name='Test Artist')
art.save()
alb = models.Album(title='test album',
album_id=12345,
import_timestamp=datetime.datetime.now(),
album_artist=art,
num_tracks=6)
alb.save()
# Add our test tracks in a fixed but random order.
test_track_nums = (4, 2, 1, 3, 6, 5)
for track_num in test_track_nums:
trk = models.Track(ufid="test ufid %d" % track_num,
album=alb,
sampling_rate_hz=44100,
bit_rate_kbps=320,
channels='stereo',
duration_ms=123456,
title="test track %d" % track_num,
track_num=track_num)
trk.save()
# Make sure the tracks come back in proper sort order.
self.assertEqual(sorted(test_track_nums),
[trk.track_num for trk in alb.sorted_tracks])
def setUp(self):
# Create and save a test artist.
self.test_artist = models.Artist(name=self.TEST_ARTIST_NAME)
self.test_artist.save()
fudge.clear_expectations()
setup_dbconfig()
def test_object_indexing(self):
idx = search.Indexer()
# Create some test artists.
art1 = models.Artist(name=u"Fall, The",
parent=idx.transaction,
key_name="art1")
art2 = models.Artist(name=u"Eno, Brian",
parent=idx.transaction,
key_name="art2")
# Create some test single-artist albums.
alb1 = models.Album(title=u"This Nation's Saving Grace",
year=1985,
album_id=12345,
label=u"Some Label",
import_timestamp=datetime.datetime.now(),
album_artist=art1,
num_tracks=123,
parent=idx.transaction)
trk1 = []
for i, track_title in enumerate(
(u"Mansion", u"Bombast", u"Cruiser's Creek", u"What You Need",
u"Spoiled Victorian Child", u"L.A.")):
trk1.append(
models.Track(ufid="test1-%d" % i,
album=alb1,
sampling_rate_hz=44110,
bit_rate_kbps=320,
channels="stereo",
duration_ms=123,
title=track_title,
track_num=i + 1,
parent=idx.transaction))
alb2 = models.Album(title=u"Another Green World",
album_id=67890,
label=u"Some Label",
import_timestamp=datetime.datetime.now(),
album_artist=art2,
num_tracks=456,
parent=idx.transaction)
trk2 = []
for i, track_title in enumerate(
(u"Sky Saw", u"Over Fire Island", u"St. Elmo's Fire",
u"In Dark Trees", u"The Big Ship")):
trk2.append(
models.Track(ufid="test2-%d" % i,
album=alb2,
sampling_rate_hz=44110,
bit_rate_kbps=192,
channels="joint_stereo",
duration_ms=456,
title=track_title,
track_num=i + 1,
parent=idx.transaction))
# Create a test album that is a compilation.
alb3 = models.Album(title=u"R&B Gold: 1976",
album_id=76543,
label=u"Some Label",
import_timestamp=datetime.datetime.now(),
is_compilation=True,
num_tracks=789,
parent=idx.transaction)
trk3_art = []
trk3 = []
for i, (artist_name, track_title) in enumerate(
((u"Earth, Wind & Fire", u"Sing A Song"),
(u"Diana Ross", u"Love Hangover"), (u"Aretha Franklin",
u"Something He Can Feel"),
(u"KC & the Sunshine Band",
u"(Shake, Shake, Shake) Shake Your Booty"))):
art = models.Artist(name=artist_name,
key_name=artist_name,
parent=idx.transaction)
trk3_art.append(art)
trk3.append(
models.Track(ufid="test3-%d" % i,
album=alb3,
sampling_rate_hz=44110,
bit_rate_kbps=128,
channels="mono",
duration_ms=789,
title=track_title,
track_artist=art,
track_num=i + 1,
parent=idx.transaction))
# Now index everything we just created.
idx.add_artist(art1)
idx.add_artist(art2)
for art in trk3_art:
idx.add_artist(art)
idx.add_album(alb1)
idx.add_album(alb2)
idx.add_album(alb3)
for trk in trk1 + trk2 + trk3:
idx.add_track(trk)
idx.save() # This also saves all of the objects.
# Now do some test searches.
# This query matches the album and all of the tracks.
expected = {alb1.key(): set(["title"])}
self.assertEqual(
expected,
search.fetch_keys_for_query_string(u"nations",
entity_kind="Album"))
for t in trk1:
expected[t.key()] = set(["album"])
self.assertEqual(expected,
search.fetch_keys_for_query_string(u"nations"))
# The query "fire" should match:
# * Two of the songs from "Another Green World"
# * The band "Earth, Wind & Fire"
# * The EW&F track from the compilation.
expected = {
trk2[1].key(): set(["title"]),
trk2[2].key(): set(["title"]),
trk3_art[0].key(): set(["name"]),
trk3[0].key(): set(["artist"]),
}
self.assertEqual(expected, search.fetch_keys_for_query_string(u"fire"))