grooveshark 0.2.11 → 0.2.12

data/lib/grooveshark/song.rb

@@ -1,25 +1,27 @@
+# Grooveshark module
 module Grooveshark
+  # Song class
   class Song
     attr_reader :data
     attr_reader :id, :artist_id, :album_id
     attr_reader :name, :artist, :album, :track, :year
     attr_reader :duration, :artwork, :playcount
 
-    def initialize(data=nil)
-      unless data.nil?
-        @data       = data
-        @id         = data['song_id']
-        @name       = data['song_name'] || data['name']
-        @artist     = data['artist_name']
-        @artist_id  = data['artist_id']
-        @album      = data['album_name']
-        @album_id   = data['album_id']
-        @track      = data['track_num']
-        @duration   = data['estimate_duration']
-        @artwork    = data['cover_art_filename']
-        @playcount  = data['song_plays']
-        @year       = data['year']
-      end
+    def initialize(data = nil)
+      return if data.nil?
+
+      @data       = data
+      @id         = data['song_id']
+      @name       = data['song_name'] || data['name']
+      @artist     = data['artist_name']
+      @artist_id  = data['artist_id']
+      @album      = data['album_name']
+      @album_id   = data['album_id']
+      @track      = data['track_num']
+      @duration   = data['estimate_duration']
+      @artwork    = data['cover_art_filename']
+      @playcount  = data['song_plays']
+      @year       = data['year']
     end
 
     # Presentable format

data/lib/grooveshark/user.rb

@@ -1,15 +1,17 @@
+# Grooveshark module
 module Grooveshark
+  # User class
   class User
-    attr_reader :id, :username, :email, :premium, :data
+    attr_reader :id, :name, :email, :premium, :data
     attr_reader :city, :country, :sex
     attr_reader :playlists, :favorites
 
     # Init user account object
-    def initialize(client, data=nil)
+    def initialize(client, data = nil)
       if data
         @data     = data
         @id       = data['user_id']
-        @username = data['username']
+        @name     = data['f_name']
         @premium  = data['is_premium']
         @email    = data['email']
         @city     = data['city']
@@ -25,9 +27,11 @@ module Grooveshark
     end
 
     # Get user activity for the date (COMES AS RAW RESPONSE)
-    def feed(date=nil)
+    def feed(date = nil)
       date = Time.now if date.nil?
-      @client.request('getProcessedUserFeedData', {:userID => @id, :day => date.strftime("%Y%m%d")})
+      @client.request('getProcessedUserFeedData',
+                      userID: @id,
+                      day: date.strftime('%Y%m%d'))
     end
 
     # --------------------------------------------------------------------------
@@ -35,26 +39,35 @@ module Grooveshark
     # --------------------------------------------------------------------------
 
     # Fetch songs from library
-    def library(page=0)
-      resp = @client.request('userGetSongsInLibrary', {:userID => @id, :page => page.to_s})['songs']
-      resp.map { |s| Song.new(s) }
+    def library(page = 0)
+      songs = []
+      resp = @client.request('userGetSongsInLibrary',
+                             userID: @id,
+                             page: page.to_s)
+      songs = resp['songs'].map do |song|
+        Song.new song
+      end if resp.key?('songs')
+      songs
     end
 
     # Add songs to user's library
-    def library_add(songs=[])
-      @client.request('userAddSongsToLibrary', {:songs => songs.map { |s| s.to_hash }})
+    def library_add(songs = [])
+      @client.request('userAddSongsToLibrary', songs: songs.map(&:to_hash))
     end
 
     # Remove song from user library
     def library_remove(song)
-      raise ArgumentError, 'Song object required' unless song.kind_of?(Song)
-      req = {:userID => @id, :songID => song.id, :albumID => song.album_id, :artistID => song.artist_id}
+      fail ArgumentError, 'Song object required' unless song.is_a?(Song)
+      req = { userID: @id,
+              songID: song.id,
+              albumID: song.album_id,
+              artistID: song.artist_id }
       @client.request('userRemoveSongFromLibrary', req)
     end
 
     # Get library modification time
     def library_ts_modified
-      @client.request('userGetLibraryTSModified', {:userID => @id})
+      @client.request('userGetLibraryTSModified', userID: @id)
     end
 
     # --------------------------------------------------------------------------
@@ -64,8 +77,10 @@ module Grooveshark
     # Fetch user playlists
     def playlists
       return @playlists if @playlists
-      results = @client.request('userGetPlaylists', :userID => @id)
-      @playlists = results['playlists'].map { |list| Playlist.new(@client, list, @id) }
+      results = @client.request('userGetPlaylists', userID: @id)
+      @playlists = results['playlists'].map do |list|
+        Playlist.new(@client, list, @id)
+      end
     end
 
     # Get playlist by ID
@@ -74,15 +89,16 @@ module Grooveshark
       result.nil? ? nil : result.first
     end
 
-    alias :playlist :get_playlist
+    alias_method :playlist, :get_playlist
 
     # Create new user playlist
-    def create_playlist(name, description='', songs=[])
-      @client.request('createPlaylist', {
-        'playlistName' => name,
-        'playlistAbout' => description,
-        'songIDs' => songs.map { |s| s.kind_of?(Song) ? s.id : s.to_s }
-      })
+    def create_playlist(name, description = '', songs = [])
+      @client.request('createPlaylist',
+                      'playlistName' => name,
+                      'playlistAbout' => description,
+                      'songIDs' => songs.map do |s|
+                        s.is_a?(Song) ? s.id : s.to_s
+                      end)
     end
 
     # --------------------------------------------------------------------------
@@ -92,20 +108,20 @@ module Grooveshark
     # Get user favorites
     def favorites
       return @favorites if @favorites
-      resp = @client.request('getFavorites', :ofWhat => 'Songs', :userID => @id)
+      resp = @client.request('getFavorites', ofWhat: 'Songs', userID: @id)
       @favorites = resp.map { |s| Song.new(s) }
     end
 
     # Add song to favorites
     def add_favorite(song)
-      song_id = song.kind_of?(Song) ? song.id : song
-      @client.request('favorite', {:what => 'Song', :ID => song_id})
+      song_id = song.is_a?(Song) ? song.id : song
+      @client.request('favorite', what: 'Song', ID: song_id)
     end
 
     # Remove song from favorites
     def remove_favorite(song)
-      song_id = song.kind_of?(Song) ? song.id : song
-      @client.request('unfavorite', {:what => 'Song', :ID => song_id})
+      song_id = song.is_a?(Song) ? song.id : song
+      @client.request('unfavorite', what: 'Song', ID: song_id)
     end
   end
 end

data/lib/grooveshark/utils.rb

@@ -1,26 +1,28 @@
+# String class
 class String
   def normalize_attribute
-    self.gsub(/^.*::/, "").
-         gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-         gsub(/([a-z\d])([A-Z])/,'\1_\2').
-         downcase
+    gsub(/^.*::/, '')
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .downcase
   end
 end
 
+# Hash class
 class Hash
   def normalize
     h = {}
-    self.each_pair do |k,v|
+    each_pair do |k, v|
       attr = k.to_s.normalize_attribute
       case v
-        when Hash
-          h[attr] = v.normalize
-        when Array
-          h[attr] = v.map { |o| o.kind_of?(Hash) ? o.normalize : o }
-        else
-          h[attr] = v
+      when Hash
+        h[attr] = v.normalize
+      when Array
+        h[attr] = v.map { |o| o.is_a?(Hash) ? o.normalize : o }
+      else
+        h[attr] = v
       end
     end
     h
   end
-end
+end

data/lib/grooveshark/version.rb

@@ -1,3 +1,4 @@
+# Grooveshark module
 module Grooveshark
-  VERSION = "0.2.11"
+  VERSION = '0.2.12'
 end

data/spec/grooveshark/broadcast_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../helper'
+
+require 'grooveshark'
+
+describe Grooveshark::Broadcast do
+  let(:client) { Grooveshark::Client.new }
+
+  describe 'search' do
+    let(:result) { client.top_broadcasts(10) }
+
+    it 'returns an array' do
+      expect(result).to be_an Array
+      expect(result.size).to eq 10
+    end
+
+    it 'includes brodcasts' do
+      all = result.all? { |item| item.is_a?(Grooveshark::Broadcast) }
+      expect(all).to be_truthy
+    end
+  end
+
+  describe 'broadcast' do
+    let(:broadcast) { client.top_broadcasts.first }
+
+    it 'has a valid id' do
+      expect(broadcast.id).to match(/^[abcdef\d]{24}$/i)
+    end
+
+    describe '#active_song' do
+      it 'is a song instance' do
+        expect(broadcast.active_song).to be_a Grooveshark::Song
+      end
+    end
+
+    describe '#next_song' do
+      it 'is a song instance' do
+        expect(broadcast.active_song).to be_a Grooveshark::Song
+      end
+    end
+  end
+end

data/spec/grooveshark/client_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../helper'
+
+require 'grooveshark'
+
+describe 'Client' do
+  context 'initialization' do
+    it 'should have a valid session' do
+      @gs = Grooveshark::Client.new
+      expect(@gs.session).to_not be_nil
+      expect(@gs.session).to match(/^[abcdef\d]{32}$/i)
+    end
+
+    it 'should have a valid country' do
+      gs = Grooveshark::Client.new
+      expect(gs.country).to be_a Hash
+      expect(gs.country.size).to eq(11)
+    end
+
+    it 'should have a valid token' do
+      @gs = Grooveshark::Client.new
+      expect(@gs.comm_token).to_not be_nil
+      expect(@gs.comm_token).to match(/^[abcdef\d]{40}$/i)
+    end
+  end
+
+  context 'authentication' do
+    it 'should raise InvalidAuthentication error for invalid credentials' do
+      @gs = Grooveshark::Client.new
+      expect { @gs.login('invlid_user_name', 'invalid_password') }
+        .to raise_error Grooveshark::InvalidAuthentication
+    end
+
+    it 'should obtain a new communication token on TTL expiration' do
+      @gs = Grooveshark::Client.new(ttl: 1)
+      @tokens = []
+
+      3.times do
+        @gs.search_songs('Muse')
+        @tokens << @gs.comm_token
+        sleep 3
+      end
+
+      @tokens.uniq!
+      expect(@tokens.size).to eq(3)
+    end
+  end
+
+  context 'search' do
+    before(:all) do
+      @gs = Grooveshark::Client.new
+    end
+
+    it 'should return empty songs collection' do
+      songs = @gs.search_songs('@@@@@%%%%%%%@%@%%@')
+      expect(songs).to be_a Array
+      expect(songs.size).to eq(0)
+    end
+
+    it 'should return songs collection' do
+      songs = @gs.search_songs('Nirvana')
+      expect(songs).to be_a Array
+      expect(songs.first).to be_a(Grooveshark::Song)
+      expect(songs.size).to_not eq(0)
+    end
+
+    it 'should return playlist' do
+      playlists = @gs.search('Playlists', 'CruciAGoT')
+      expect(playlists).to be_a(Array)
+      expect(playlists.first).to be_a(Grooveshark::Playlist)
+      expect(playlists.size).to_not eq(0)
+    end
+
+    it 'should return result' do
+      artists = @gs.search('Artists', 'Nirvana')
+      expect(artists).to be_a(Array)
+      expect(artists.first).to be_a(Hash)
+      expect(artists.size).to_not eq(0)
+    end
+  end
+end

data/spec/grooveshark/errors_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../helper'
+
+require 'grooveshark'
+
+describe 'Errors' do
+  it 'should test ApiError' do
+    fault = {
+      'code' => '25',
+      'message' => 'Something went wrong'
+    }
+
+    error = Grooveshark::ApiError.new(fault)
+    expect(error.to_s).to eq('25 - Something went wrong')
+  end
+end

data/spec/grooveshark/playlist_spec.rb

@@ -0,0 +1,98 @@
+require_relative '../helper'
+
+require 'grooveshark'
+
+describe 'Playlist' do
+  it 'should initialize without data' do
+    expect(Grooveshark::Playlist.new(double).id).to be_nil
+  end
+
+  it 'should initialize with data' do
+    playlist = Grooveshark::Playlist
+               .new(double,
+                    'playlist_id' => '1',
+                    'name' => 'something',
+                    'about' => 'me',
+                    'picture' => 'ruby.jpg',
+                    'user_id' => '2',
+                    'user_name' => 'PierreRambaud')
+    expect(playlist.id).to eq('1')
+    expect(playlist.name).to eq('something')
+    expect(playlist.about).to eq('me')
+    expect(playlist.picture).to eq('ruby.jpg')
+    expect(playlist.user_id).to eq('2')
+    expect(playlist.username).to eq('PierreRambaud')
+  end
+
+  it 'should initiliaze without data and user_id' do
+    playlist = Grooveshark::Playlist.new(double, nil, '2')
+    expect(playlist.id).to be_nil
+    expect(playlist.user_id).to be_nil
+  end
+
+  it 'should initiliaze with data and user_id' do
+    playlist = Grooveshark::Playlist
+               .new(double, { 'playlist_id' => '1' }, '2')
+    expect(playlist.id).to eq('1')
+    expect(playlist.user_id).to eq('2')
+  end
+
+  it "shouldn't load songs if playlist isn't found" do
+    client = double
+    allow(client).to receive(:request)
+      .with('getPlaylistByID', playlistID: nil).and_return({})
+    expect(Grooveshark::Playlist.new(client).load_songs).to eq([])
+  end
+
+  it 'should load songs if playlist is found' do
+    client = double
+    allow(client).to receive(:request)
+      .with('getPlaylistByID', playlistID: nil)
+      .and_return('songs' => ['song_id' => '42',
+                              'name' => 'End of days',
+                              'artist_name' => 'Vinnie Paz'])
+    songs = Grooveshark::Playlist.new(client).load_songs
+    expect(songs.first).to be_a(Grooveshark::Song)
+    expect(songs.first.to_s).to eq('42 - End of days - Vinnie Paz')
+  end
+
+  it 'should rename playlist' do
+    client = double
+    allow(client).to receive(:request)
+      .with('renamePlaylist', playlistID: '2', playlistName: 'GoT')
+      .and_return(true)
+
+    allow(client).to receive(:request)
+      .with('setPlaylistAbout', playlistID: '2', about: 'Description')
+      .and_return(true)
+
+    playlist = Grooveshark::Playlist.new(client, 'playlist_id' => '2')
+    expect(playlist.rename('GoT', 'Description')).to eq(true)
+    expect(playlist.name).to eq('GoT')
+    expect(playlist.about).to eq('Description')
+  end
+
+  it 'should return false when rename playlist failed' do
+    client = double
+    allow(client).to receive(:request)
+      .with('renamePlaylist', playlistID: '2', playlistName: 'GoT')
+      .and_raise(ArgumentError)
+
+    playlist = Grooveshark::Playlist.new(client, 'playlist_id' => '2')
+    expect(playlist.rename('GoT', 'Description')).to eq(false)
+    expect(playlist.name).to be_nil
+    expect(playlist.about).to be_nil
+  end
+
+  it 'should delete playlist' do
+    client = double
+    allow(client).to receive(:request)
+      .with('deletePlaylist', playlistID: '2', name: 'GoT')
+      .and_return(true)
+
+    playlist = Grooveshark::Playlist.new(client,
+                                         'playlist_id' => '2',
+                                         'name' => 'GoT')
+    expect(playlist.delete).to eq(true)
+  end
+end