xhochy-scrobbler 0.2.14

data/test/mocks/rest.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/../../lib/scrobbler/rest'
+require 'digest/md5'
+
+module Scrobbler
+  module REST
+  	class Connection
+  	  # reads xml fixture file instead of hitting up the internets
+  	  def request(resource, method = "get", args = nil)
+  	    @now_playing_url = 'http://62.216.251.203:80/nowplaying'
+  	    @submission_url = 'http://62.216.251.205:80/protocol_1.2'
+  	    @session_id = '17E61E13454CDD8B68E8D7DEEEDF6170'
+  	    
+  	    if @base_url == Scrobbler::API_URL
+    	    pieces = resource.split('/')
+          pieces.shift
+    	    api_version = pieces.shift
+          if api_version == "1.0"
+            folder = pieces.shift
+            file   = pieces.last[0, pieces.last.index('.xml')]
+            base_pieces = pieces.last.split('?')
+
+            file = if base_pieces.size > 1
+              # if query string params are in resource they are underscore separated for filenames
+              base_pieces.last.split('&').inject("#{file}_") { |str, pair| str << pair.split('=').join('_') + '_'; str }.chop!
+            else
+              file
+            end
+
+            File.read(File.dirname(__FILE__) + "/../fixtures/xml/#{folder}/#{file}.xml")
+          elsif api_version == "2.0"
+            method_pieces = pieces.last.split('&')
+            api_method = method_pieces.shift
+            if api_method == '?method=artist.search'
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/search/artist.xml")
+            elsif api_method == '?method=album.search'
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/search/album.xml")
+            elsif api_method == '?method=track.search'
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/search/track.xml")
+            elsif pieces.last =~ /[?&]method=album\.getinfo/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/album/info.xml")
+            elsif pieces.last =~ /[?&]method=artist\.gettoptags/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/artist/toptags.xml")
+            elsif pieces.last =~ /[?&]method=artist\.gettopfans/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/artist/fans.xml")
+            elsif pieces.last =~ /[?&]method=artist\.gettoptracks/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/artist/toptracks.xml")
+            elsif pieces.last =~ /[?&]method=artist\.gettopalbums/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/artist/topalbums.xml")
+            elsif pieces.last =~ /[?&]method=artist\.getsimilar/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/artist/similar.xml")
+            elsif pieces.last =~ /[?&]method=tag\.gettoptracks/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/tag/toptracks.xml")
+            elsif pieces.last =~ /[?&]method=tag\.gettopartists/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/tag/topartists.xml")
+            elsif pieces.last =~ /[?&]method=tag\.gettopalbums/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/tag/topalbums.xml")
+            elsif pieces.last =~ /[?&]method=track\.gettoptags/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/track/toptags.xml")
+            elsif pieces.last =~ /[?&]method=track\.gettopfans/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/track/fans.xml")
+            elsif pieces.last =~ /[?&]method=user\.gettopartists/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/user/topartists.xml")
+            elsif pieces.last =~ /[?&]method=user\.gettopalbums/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/user/topalbums.xml")
+            elsif pieces.last =~ /[?&]method=user\.gettoptracks/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/user/toptracks.xml")
+            elsif pieces.last =~ /[?&]method=user\.getfriends/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/user/friends.xml")
+            elsif pieces.last =~ /[?&]method=user\.gettoptags/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/user/toptags.xml")
+            elsif pieces.last =~ /[?&]method=user\.getneighbours/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/user/neighbours.xml")
+            elsif pieces.last =~ /[?&]method=user\.getrecenttracks/
+              return File.read(File.dirname(__FILE__) + "/../fixtures/xml/user/recenttracks.xml")
+            else
+              throw Exception.new("Illegal or unsupported Last.FM method called")
+            end
+          end
+  	    elsif @base_url == Scrobbler::AUTH_URL
+          if args[:hs] == "true" && args[:p] == Scrobbler::AUTH_VER.to_s && args[:c] == 'rbs' &&
+             args[:v] == Scrobbler::Version.to_s && args[:u] == 'chunky' && !args[:t].blank? &&
+             args[:a] == Digest::MD5.hexdigest('7813258ef8c6b632dde8cc80f6bda62f' + args[:t])
+            
+            "OK\n#{@session_id}\n#{@now_playing_url}\n#{@submission_url}"
+          end
+        elsif @base_url == @now_playing_url
+          if args[:s] == @session_id && ![args[:a], args[:t], args[:b], args[:n]].any?(&:blank?)
+             'OK'
+          end           
+        elsif @base_url == @submission_url
+          if args[:s] == @session_id && 
+             ![args['a[0]'], args['t[0]'], args['i[0]'], args['o[0]'], args['l[0]'], args['b[0]']].any?(&:blank?)
+            'OK'
+          end
+        elsif @base_url == @scrobbler_api_url_v2
+          File.read(File.dirname(__FILE__) + "/../fixtures/xml/search/album.xml")
+	      end
+	      
+	    end
+	  end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/scrobbler'
+require File.dirname(__FILE__) + '/mocks/rest'
+
+# To test the 2.0 API, we do not need a valid key
+Scrobbler::Base.api_key = 'foo123'
+
+class << Test::Unit::TestCase
+  def test(name, &block)
+    test_name = :"test_#{name.gsub(' ','_')}"
+    raise ArgumentError, "#{test_name} is already defined" if self.instance_methods.include? test_name.to_s
+    define_method test_name, &block
+  end
+  
+  def expect(expected_value, &block)
+    define_method :"test_#{caller.first.split("/").last}" do
+      assert_equal expected_value, instance_eval(&block)
+    end 
+  end
+end

data/test/unit/album_test.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestAlbum < Test::Unit::TestCase
+
+  def setup
+    @album = Scrobbler::Album.new('Carrie Underwood', 'Some Hearts')
+  end
+  
+  # @apiversion 2.0
+  test 'should require the artist name' do
+    assert_raises(ArgumentError) { Scrobbler::Album.new('', 'Some Hearts') }
+  end
+  
+  test 'should require the track name' do
+    assert_raises(ArgumentError) { Scrobbler::Album.new('Carrie Underwood', '') }
+  end
+  
+  test 'should know the artist' do
+    assert_equal('Carrie Underwood', @album.artist)
+  end
+  
+  test "should know it's name" do
+    assert_equal('Some Hearts', @album.name)
+  end
+  
+  test 'should be able to load album info' do
+    @album.load_info
+    assert_equal('http://www.last.fm/music/Carrie+Underwood/Some+Hearts', @album.url)
+    assert_equal(Time.mktime(2005, 11, 15, 00, 00, 00), @album.release_date)
+  end
+  
+  test 'should be able to find an ablum' do
+    album = Scrobbler::Album.find('Carrie Underwood', 'Some Hearts')
+    assert_equal('Carrie Underwood', album.artist)
+    assert_equal('Some Hearts', album.name)
+  end
+  
+  test "should be able to find an ablum and load the album's info" do
+    album = Scrobbler::Album.find('Carrie Underwood', 'Some Hearts', :include_info => true)
+    assert_equal('Carrie Underwood', album.artist)
+    assert_equal('Some Hearts', album.name)
+    assert_equal('http://www.last.fm/music/Carrie+Underwood/Some+Hearts', album.url)
+    assert_equal(131312, album.listeners)
+    assert_equal(2096260, album.playcount)
+    assert_equal(Time.mktime(2005, 11, 15, 00, 00, 00), album.release_date)
+    assert_equal(["country", "albums i own", "pop", "country pop", "american idol"], album.top_tags.collect(&:name))
+  end
+  
+  test "should be able to include the album's info on initialize" do
+    album = Scrobbler::Album.new('Carrie Underwood', 'Some Hearts', :include_info => true)
+    assert_equal('Carrie Underwood', album.artist)
+    assert_equal('Some Hearts', album.name)
+    assert_equal('http://www.last.fm/music/Carrie+Underwood/Some+Hearts', album.url)
+    assert_equal(Time.mktime(2005, 11, 15, 00, 00, 00), album.release_date)
+  end
+  
+  test 'should have an image method that accepts a type' do
+    @album.load_info
+    assert_equal('http://userserve-ak.last.fm/serve/34s/19874169.jpg', @album.image(:small))
+    assert_equal('http://userserve-ak.last.fm/serve/64s/19874169.jpg', @album.image(:medium))
+    assert_equal('http://userserve-ak.last.fm/serve/174s/19874169.jpg', @album.image(:large))
+    assert_equal('http://userserve-ak.last.fm/serve/300x300/19874169.jpg', @album.image(:extralarge))
+  end
+  
+  test "should raise an argument error when attempting to get an image that doesn't exist" do
+    @album.load_info
+    assert_raises(ArgumentError) { @album.image(:fake) }
+  end
+  
+  test 'should load info when trying to access an image if the info has not been loaded' do
+    assert_equal('http://userserve-ak.last.fm/serve/34s/19874169.jpg', @album.image(:small))
+  end
+end

data/test/unit/artist_test.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestArtist < Test::Unit::TestCase
+
+  def setup
+    @artist = Scrobbler::Artist.new('Metallica')
+    
+    @similar_artists = ["Megadeth", "Pantera", "Slayer", "Iron Maiden", 
+      "Anthrax", "Machine Head", "Sepultura", "Motörhead", "Testament",
+      "Trivium", "Black Sabbath", "Exodus", "Ozzy Osbourne", "AC/DC",
+      "Kreator", "Black Label Society", "Guns N' Roses", "System of a Down",
+      "Judas Priest", "Soulfly", "Godsmack", "Children of Bodom", "Slipknot",
+      "Disturbed", "Hunter", "Apocalyptica", "Iced Earth", "Annihilator",
+      "Rammstein", "KoЯn", "Death Angel", "In Flames", "Lamb of God", "Overkill",
+      "Diamond Head", "Damageplan", "Acid Drinkers", "Beatallica", "Stone Sour",
+      "Metal Church", "MD.45", "Volbeat", "HammerFall","Black Tide",
+      "Rage Against the Machine", "Manowar", "Probot", "Bullet For My Valentine",
+      "Flotsam and Jetsam", "Dio", "Roadrunner United", "Venom", "Arch Enemy",
+      "Mercyful Fate", "Nuclear Assault", "Destruction", "Blind Guardian",
+      "Sacred Reich", "Bruce Dickinson", "Turbo", "Static-X", "Helloween",
+      "Zakk Wylde", "Avenged Sevenfold", "W.A.S.P.", "Kat", "Skid Row",
+      "DevilDriver", "Danzig", "Heathen", "Mokoma", "Lordi", "Shadows Fall",
+      "Chimaira", "Whiplash", "Mudvayne", "Onslaught", "Sodom", "Rage",
+      "Forbidden", "Evile", "Savatage", "Scorpions", "DragonForce",
+      "Axel Rudi Pell", "Rob Zombie", "Killswitch Engage", "Sebastian Bach",
+      "Saxon", "Cavalera Conspiracy", "Voivod", "Drowning Pool",
+      "Fear Factory", "Mötley Crüe", "Prong", "Kotiteollisuus", "Stone",
+      "Fozzy", "Yngwie Malmsteen", "Deep Purple"]
+    @top_albums = ["Master of Puppets", "Metallica", "Ride the Lightning", "Reload"]
+    @top_fans = ["Slide15", "Air_Force", "Evile9", "thy_satan", "Aiham", "Quugel"]
+    @top_tracks = ['Nothing Else Matters', 'Enter Sandman', 
+        'The Day That Never Comes', 'One']
+  end
+  
+  # @apiversion 2.0
+  test 'should require name' do
+    assert_raises(ArgumentError) { Scrobbler::Artist.new('') }
+  end
+  
+  # @apiversion 2.0
+  test "should know it's name" do
+    assert_equal('Metallica', @artist.name)
+  end
+  
+  test 'should have the correct ical path to current events' do
+    assert_equal('http://ws.audioscrobbler.com/2.0/artist/Metallica/events.ics', @artist.current_events(:ical))
+  end
+
+  test 'should have the correct rss path to current events' do
+    assert_equal('http://ws.audioscrobbler.com/2.0/artist/Metallica/events.rss', @artist.current_events(:rss))
+  end
+  
+  # @apiversion 2.0
+  test 'should be able to find similar artists' do
+    assert_equal(@similar_artists, @artist.similar.collect(&:name))
+    first = @artist.similar.first
+    assert_equal('Megadeth', first.name)
+    assert_equal('a9044915-8be3-4c7e-b11f-9e2d2ea0a91e', first.mbid)
+    assert_equal('100', first.match)
+    assert_equal('www.last.fm/music/Megadeth', first.url)
+    assert_equal('http://userserve-ak.last.fm/serve/34/8422011.jpg', first.image(:small))
+    assert_equal('http://userserve-ak.last.fm/serve/64/8422011.jpg', first.image(:medium))
+    assert_equal('http://userserve-ak.last.fm/serve/126/8422011.jpg', first.image(:large))
+    assert_equal('yes', first.streamable)
+  end
+  
+  # @apiversion 2.0
+  test 'should be able to find top fans' do
+    assert_equal(@top_fans, @artist.top_fans.collect(&:username))
+    first = @artist.top_fans.first
+    assert_equal('Slide15', first.username)
+    assert_equal('http://www.last.fm/user/Slide15', first.url)
+    assert_equal('http://userserve-ak.last.fm/serve/34/4477633.jpg', first.avatar)
+    assert_equal('265440672', first.weight)
+  end
+  
+  # @apiversion 2.0
+  test 'should be able to find top tracks' do
+    assert_equal(@top_tracks, @artist.top_tracks.collect(&:name))
+    first = @artist.top_tracks.first
+    assert_equal('Nothing Else Matters', first.name)
+    assert_equal('', first.mbid)
+    assert_equal('http://www.last.fm/music/Metallica/_/Nothing+Else+Matters', first.url)
+  end
+  
+  # @apiversion 2.0
+  test 'should be able to find top albums' do
+    assert_equal(@top_albums, @artist.top_albums.collect(&:name))
+    first = @artist.top_albums.first
+    assert_equal('Master of Puppets', first.name)
+    assert_equal('fed37cfc-2a6d-4569-9ac0-501a7c7598eb', first.mbid)
+    assert_equal('http://www.last.fm/music/Metallica/Master+of+Puppets', first.url)
+    assert_equal('http://userserve-ak.last.fm/serve/34s/8622967.jpg', first.image(:small))
+    assert_equal('http://userserve-ak.last.fm/serve/64s/8622967.jpg', first.image(:medium))
+    assert_equal('http://userserve-ak.last.fm/serve/126/8622967.jpg', first.image(:large))    
+  end
+  
+  # @apiversion 2.0
+  test 'should be able to find top tags' do
+    assert_equal(['metal', 'thrash metal', 'heavy metal'], @artist.top_tags.collect(&:name))
+    first = @artist.top_tags.first
+    assert_equal('metal', first.name)
+    assert_equal('100', first.count)
+    assert_equal('http://www.last.fm/tag/metal', first.url)
+  end
+end

data/test/unit/chart_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestChart < Test::Unit::TestCase
+
+  def setup
+    @chart = Scrobbler::Chart.new('1108296002', '1108900802')
+  end
+  
+  test 'should require from' do
+    assert_raise(ArgumentError) { Scrobbler::Chart.new('', '1108900802') }
+  end
+  
+  test 'should require to' do
+    assert_raise(ArgumentError) { Scrobbler::Chart.new('1108296002', '') }
+  end
+  
+  test 'should be able to parse to and from that are unix timestamp strings' do
+    chart = Scrobbler::Chart.new('1108296002', '1108900802')
+    assert_equal(1108296002, chart.from)
+    assert_equal(1108900802, chart.to)
+  end
+  
+  test 'should be able to parse to and from that are unix timestamp fixnums' do
+    chart = Scrobbler::Chart.new(1108296002, 1108900802)
+    assert_equal(1108296002, chart.from)
+    assert_equal(1108900802, chart.to)
+  end
+  
+  test 'should be able to parse to and from that are times' do
+    chart = Scrobbler::Chart.new(Time.at(1108296002), Time.at(1108900802))
+    assert_equal(1108296002, chart.from)
+    assert_equal(1108900802, chart.to)
+  end
+end

data/test/unit/playing_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestPlaying < Test::Unit::TestCase
+  
+  def setup
+    @session_id = '17E61E13454CDD8B68E8D7DEEEDF6170'
+    @now_playing_url = 'http://62.216.251.203:80/nowplaying'
+    @artist = 'Anberlin'
+    @track = 'A Day Late'
+    @album = 'Never Take Friendship Personal'
+    
+    @playing = Scrobbler::Playing.new(:session_id => @session_id, :now_playing_url => @now_playing_url,
+                                      :artist => @artist, :track => @track, :album => @album, :length => 214,
+                                      :track_number => 5)
+  end
+  
+  test 'should require a session id' do
+    assert_raises(ArgumentError) { Scrobbler::Playing.new(
+                                      :now_playing_url => @now_playing_url, :artist => @artist, :track => @track,
+                                      :album => @album, :length => 214, :track_number => 5) }
+  end
+  
+  test 'should require a now playing url' do
+    assert_raises(ArgumentError) { Scrobbler::Playing.new(
+                                      :session_id => @session_id, :artist => @artist, :track => @track,
+                                      :album => @album, :length => 214, :track_number => 5) }
+  end
+  
+  test 'should require an artist' do
+    assert_raises(ArgumentError) { Scrobbler::Playing.new(
+                                      :session_id => @session_id, :now_playing_url => @now_playing_url,
+                                      :track => @track, :album => @album, :length => 214, :track_number => 5) }
+  end
+  
+  test 'should require a track' do
+    assert_raises(ArgumentError) { Scrobbler::Playing.new(
+                                      :session_id => @session_id, :now_playing_url => @now_playing_url,
+                                      :artist => @artist, :album => @album, :length => 214, :track_number => 5) }
+  end
+  
+  test 'should require a length greater than 30 seconds' do
+    assert_raises(ArgumentError) { Scrobbler::Playing.new(
+                                      :session_id => @session_id, :now_playing_url => @now_playing_url,
+                                      :artist => @artist, :track => @track, :album => @album, :length => 29,
+                                      :track_number => 5) }
+  end
+  
+  test 'should submit successfully' do
+    @playing.submit!
+    assert_equal('OK', @playing.status)
+  end
+  
+end

data/test/unit/scrobble_test.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestScrobble < Test::Unit::TestCase
+  
+  def setup
+    @session_id = '17E61E13454CDD8B68E8D7DEEEDF6170'
+    @submission_url = 'http://62.216.251.205:80/protocol_1.2'
+    @artist = 'Coldplay'
+    @name = 'Viva La Vida'
+    
+    @scrobble = Scrobbler::Scrobble.new(:session_id => @session_id, :submission_url => @submission_url,
+                                        :artist => @artist, :track => @name, :album => @name, :time => Time.new,
+                                        :length => 244, :track_number => 7)
+  end
+  
+  test 'should require a session id' do
+    assert_raises(ArgumentError) { Scrobbler::Scrobble.new(:submission_url => @submission_url,
+                                        :artist => @artist, :track => @name, :album => @name, :time => Time.new,
+                                        :length => 244, :track_number => 7) }
+  end
+  
+  test 'should require a submission url' do
+    assert_raises(ArgumentError) { Scrobbler::Scrobble.new(:session_id => @session_id,
+                                        :artist => @artist, :track => @name, :album => @name, :time => Time.new,
+                                        :length => 244, :track_number => 7) }
+  end
+  
+  test 'should require an artist' do
+    assert_raises(ArgumentError) { Scrobbler::Scrobble.new(:session_id => @session_id, :submission_url => @submission_url,
+                                        :track => @name, :album => @name, :time => Time.new,
+                                        :length => 244, :track_number => 7) }
+  end
+  
+  test 'should require a track' do
+    assert_raises(ArgumentError) { Scrobbler::Scrobble.new(:session_id => @session_id, :submission_url => @submission_url,
+                                        :artist => @artist, :album => @name, :time => Time.new,
+                                        :length => 244, :track_number => 7) }
+  end
+  
+  test 'should require a Time object' do
+    assert_raises(ArgumentError) { Scrobbler::Scrobble.new(:session_id => @session_id, :submission_url => @submission_url,
+                                        :artist => @artist, :track => @name, :album => @name, :time => 'chunky_bacon',
+                                        :length => 244, :track_number => 7) }
+  end
+  
+  test 'should require a valid source' do
+    assert_raises(ArgumentError) { Scrobbler::Scrobble.new(:session_id => @session_id, :submission_url => @submission_url,
+                                        :artist => @artist, :track => @name, :album => @name, :time => Time.new,
+                                        :length => 244, :track_number => 7, :source => 'Z') }
+  end
+  
+  test 'should require a length if source is set to P' do
+    assert_raises(ArgumentError) { Scrobbler::Scrobble.new(:session_id => @session_id, :submission_url => @submission_url,
+                                        :artist => @artist, :track => @name, :album => @name, :time => Time.new,
+                                        :track_number => 7, :source => 'P') }
+  end
+  
+  test 'should require a length greater than 30 if source is set to P' do
+    assert_raises(ArgumentError) { Scrobbler::Scrobble.new(:session_id => @session_id, :submission_url => @submission_url,
+                                        :artist => @artist, :track => @name, :album => @name, :time => Time.new,
+                                        :length => 29, :track_number => 7, :source => 'P') }
+  end
+  
+  test 'should submit successfully' do
+    @scrobble.submit!
+    assert_equal('OK', @scrobble.status)
+  end
+  
+end