hallon 0.8.0 → 0.9.0

data/spec/hallon/spotify_spec.rb

@@ -0,0 +1,30 @@
+describe Spotify do
+  describe "a wrapped function" do
+    let(:null_pointer) { FFI::Pointer.new(0) }
+    subject do
+      Spotify.should_receive(:session_user).and_return(null_pointer)
+      Spotify.session_user!(session)
+    end
+
+    it "should return a Spotify::Pointer" do
+      subject.should be_a Spotify::Pointer
+    end
+
+    it "should not add ref when the result is nil" do
+      Spotify.should_not_receive(:user_add_ref)
+      subject.should be_null
+    end
+  end
+
+  describe "garbage collection" do
+    let(:my_pointer) { FFI::Pointer.new(1) }
+
+    it "should work" do
+      # GC tests are a bit funky, but as long as we garbage_release at least once, then
+      # we can assume our GC works properly, but up the stakes just for the sake of it
+      Spotify.should_receive(:garbage_release).with(my_pointer).at_least(3).times
+      5.times { Spotify::Pointer.new(my_pointer, :garbage, false) }
+      5.times { GC.start; sleep 0.1 }
+    end
+  end
+end

data/spec/hallon/toplist_spec.rb

@@ -1,14 +1,14 @@
 describe Hallon::Toplist do
-  subject do
-    mock_session do
-      Spotify.should_receive(:toplistbrowse_create).and_return(mock_toplistbrowse)
-      Hallon::Toplist.new(:artists)
-    end
+  let(:toplist) do
+    Spotify.registry_add 'spotify:toplist:artists:everywhere', mock_toplistbrowse
+    mock_session { Hallon::Toplist.new(:artists) }
   end
 
+  subject { toplist }
+
   it { should be_a Hallon::Observable }
   it { should be_loaded }
-  its(:error) { should eq :ok }
+  its(:status) { should eq :ok }
 
   its('artists.size') { should eq 2 }
   its('artists.to_a') { should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two) }
@@ -19,22 +19,30 @@ describe Hallon::Toplist do
   its('tracks.size') { should eq 2 }
   its('tracks.to_a') { should eq instantiate(Hallon::Track, mock_track, mock_track_two) }
 
-  describe ".new" do
-    around { |test| mock_session(&test) }
+  describe "#request_duration" do
+    it "should return the request duration in seconds" do
+      toplist.request_duration.should eq 2.751
+    end
 
+    it "should be nil if the request was fetched from local cache" do
+      Spotify.should_receive(:toplistbrowse_backend_request_duration).and_return(-1)
+      toplist.request_duration.should be_nil
+    end
+  end
+
+  describe ".new" do
     it "should fail given an invalid type" do
-      expect { Hallon::Toplist.new(:invalid_type) }.to raise_error(ArgumentError, /invalid enum value/)
+      expect { mock_session { Hallon::Toplist.new(:invalid_type) } }.to raise_error(ArgumentError, /invalid enum value/)
     end
 
     it "should pass the username given a string to libspotify" do
-      Spotify.should_receive(:toplistbrowse_create).with(anything, anything, :user, "Kim", anything, nil).and_return(null_pointer)
-      Hallon::Toplist.new(:artists, "Kim")
+      Spotify.registry_add 'spotify:toplist:user:Kim', mock_toplistbrowse
+      mock_session { Hallon::Toplist.new(:tracks, "Kim").should be_loaded }
     end
 
     it "should pass the correct region to libspotify" do
-      sweden = 21317
-      Spotify.should_receive(:toplistbrowse_create).with(anything, anything, sweden, anything, anything, nil).and_return(null_pointer)
-      Hallon::Toplist.new(:artists, :se)
+      Spotify.registry_add 'spotify:toplist:tracks:SE', mock_toplistbrowse
+      mock_session { Hallon::Toplist.new(:tracks, :se).should be_loaded }
     end
   end
 end

data/spec/hallon/track_spec.rb

@@ -1,6 +1,11 @@
 # coding: utf-8
 describe Hallon::Track do
-  subject { Hallon::Track.new(mock_track) }
+  it_should_behave_like "a Linkable object" do
+    let(:spotify_uri) { "spotify:track:7N2Vc8u56VGA4KUrGbikC2#01:00" }
+  end
+
+  let(:track) { Hallon::Track.new(mock_track) }
+  subject { track }
 
   it { should be_loaded }
   its(:name)   { should eq "They" }
@@ -18,20 +23,19 @@ describe Hallon::Track do
     around { |test| mock_session(&test) }
 
     it "should delegate to session to unstar" do
-      session.should_receive(:unstar).with(subject)
-      subject.starred = false
+      session.should_receive(:unstar).with(track)
+      track.starred = false
     end
 
-
     it "should delegate to session to star" do
-      session.should_receive(:star).with(subject)
-      subject.starred = true
+      session.should_receive(:star).with(track)
+      track.starred = true
     end
 
     it "should change starred status of track" do
-      subject.should be_starred
-      subject.starred = false
-      subject.should_not be_starred
+      track.should be_starred
+      track.starred = false
+      track.should_not be_starred
     end
   end
 
@@ -43,34 +47,67 @@ describe Hallon::Track do
     it { should_not be_local }
     it { should be_autolinked }
     it { should be_starred }
+
+    its(:availability) { should eq :available }
   end
 
   describe "album" do
     it "should be an album when there is one" do
-      subject.album.should eq Hallon::Album.new(mock_album)
+      track.album.should eq Hallon::Album.new(mock_album)
     end
 
     it "should be nil when there isn’t one" do
-      Spotify.should_receive(:track_album).and_return(FFI::Pointer.new(0))
-      subject.album.should be_nil
+      Spotify.should_receive(:track_album).and_return(null_pointer)
+      track.album.should be_nil
     end
   end
 
   describe "to_link" do
-    before(:each) { Hallon::Link.stub(:new) }
-
     it "should pass the current offset by default" do
-      Spotify.should_receive(:link_create_from_track).with(subject.pointer, 10_000)
-      subject.should_receive(:offset).and_return(10)
-
-      subject.to_link
+      track.should_receive(:offset).and_return(10)
+      track.to_link.to_str.should match(/#00:10/)
     end
 
     it "should accept offset as parameter" do
-      Spotify.should_receive(:link_create_from_track).with(subject.pointer, 1_337_000)
-      subject.should_not_receive(:offset)
+      track.should_not_receive(:offset)
+      track.to_link(1337).to_str.should match(/#22:17/)
+    end
+  end
+
+  describe "#placeholder?" do
+    let(:yes) { Hallon::Track.new(mock_track_two) }
+
+    it "should return the placeholder status of the track" do
+      yes.should be_placeholder
+      track.should_not be_placeholder
+    end
+  end
+
+  describe "#unwrap" do
+    let(:track) { Hallon::Track.new(mock_track_two) }
+    let(:playlist) { Spotify.link_create_from_string!('spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi') }
+    let(:artist)   { Spotify.link_create_from_string!('spotify:artist:3bftcFwl4vqRNNORRsqm1G') }
+    let(:album)    { Spotify.link_create_from_string!('spotify:album:1xvnWMz2PNFf7mXOSRuLws') }
+
+    it "should unwrap a playlist placeholder into a playlist" do
+      Spotify.should_receive(:link_create_from_track!).and_return(playlist)
+      mock_session { track.unwrap.should eq Hallon::Playlist.new(playlist) }
+    end
+
+    it "should unwrap an album placeholder into an album" do
+      Spotify.should_receive(:link_create_from_track!).and_return(album)
+      track.unwrap.should eq Hallon::Album.new(album)
+    end
 
-      subject.to_link(1337)
+    it "should unwrap an artist placeholder into an artist" do
+      Spotify.should_receive(:link_create_from_track!).and_return(artist)
+      track.unwrap.should eq Hallon::Artist.new(artist)
+    end
+  end
+
+  describe "#offline_status" do
+    it "should return the tracks’ offline status" do
+      track.offline_status.should eq :done
     end
   end
 
@@ -85,6 +122,10 @@ describe Hallon::Track do
     specify "without offset" do
       Hallon::Track.new(without_offset).offset.should eq 0
     end
+
+    specify "when instantiated from a pointer" do
+      Hallon::Track.new(mock_track).offset.should eq 0
+    end
   end
 
   describe "a local track" do

data/spec/hallon/user_spec.rb

@@ -1,34 +1,18 @@
 # coding: utf-8
 describe Hallon::User do
-  describe ".new" do
-    it "should raise ArgumentError when given an invalid link" do
-      expect { Hallon::User.new("invalid link") }.to raise_error ArgumentError
-    end
-
-    it "should raise ArgumentError when given a non-user link" do
-      expect { Hallon::User.new("spotify:search:moo") }.to raise_error ArgumentError
-    end
+  it_should_behave_like "a Linkable object" do
+    let(:spotify_uri) { "spotify:user:burgestrand" }
+    let(:custom_object) { "burgestrand" }
   end
 
-  describe "creating a User", :logged_in => true do
-    context ".new", "from a Spotify URI" do
-      subject { Hallon::User.new("spotify:user:burgestrand") }
-      it_should_behave_like "a loadable object"
-    end
-
-    context ".new", "from a Link" do
-      subject { Hallon::User.new Hallon::Link.new("spotify:user:burgestrand") }
-      it_should_behave_like "a loadable object"
-    end
+  describe "an instance" do
+    let(:user) { Hallon::User.new(mock_user) }
 
-    context "from Session#user" do
-      subject { session.user }
-      it_should_behave_like "a loadable object"
+    describe "#loaded?" do
+      it "should return true as the user is loaded" do
+        user.should be_loaded
+      end
     end
-  end
-
-  describe "an instance", :logged_in => true do
-    let(:user) { Hallon::User.new(mock_user) }
 
     describe "#to_link" do
       it "should return a Link for this user" do
@@ -37,26 +21,53 @@ describe Hallon::User do
     end
 
     describe "#name" do
-      it "should be able to get the display name" do
-        user.name(:display).should eq "Burgestrand"
+      it "should be the canonical name" do
+        user.name.should eq "burgestrand"
       end
+    end
 
-      it "should be able to get the full name" do
-        user.name(:full).should eq "Kim Burgestrand"
+    describe "#display_name" do
+      it "should be the users’ display name" do
+        user.display_name.should eq "Burgestrand"
       end
+    end
 
-      it "should get the canonical name when unspecified" do
-        user.name.should eq "burgestrand"
+    describe "#post" do
+      let(:post) { mock_session { user.post(tracks) } }
+      let(:tracks) { instantiate(Hallon::Track, mock_track, mock_track_two) }
+
+      it "should have an error status" do
+        post.status.should eq :ok
+      end
+
+      it "should post to the correct user" do
+        Spotify.should_receive(:inbox_post_tracks).with(any_args, user.name, any_args, any_args, any_args, any_args, any_args).and_return(null_pointer)
+        mock_session { user.post(tracks) }
       end
 
-      it "should fail on invalid name types" do
-        expect { user.name(:i_am_invalid) }.to raise_error
+      it "should use given message if available" do
+        Spotify.should_receive(:inbox_post_tracks).with(any_args, any_args, any_args, any_args, "Hello there", any_args, any_args).and_return(null_pointer)
+        mock_session { user.post("Hello there", tracks) }
+      end
+
+      it "should return nil on failure" do
+        Spotify.should_receive(:inbox_post_tracks).and_return(null_pointer)
+        mock_session { user.post([]).should be_nil }
       end
     end
 
-    describe "#picture" do
-      it "should retrieve the user picture" do
-        user.picture.should eq "https://secure.gravatar.com/avatar/b67b73b5b1fd84119ec788b1c3df02ad"
+    describe "#starred" do
+      let(:starred) { Hallon::Playlist.new("spotify:user:%s:starred" % user.name) }
+
+      it "should return the users’ starred playlist" do
+        session.login 'Kim', 'pass'
+        session.should be_logged_in
+        mock_session { user.starred.should eq starred }
+      end
+
+      it "should return nil if not logged in" do
+        session.should_not be_logged_in
+        mock_session { user.starred.should be_nil }
       end
     end
   end

data/spec/mockspotify.rb

@@ -5,7 +5,7 @@ module Spotify
   module Mock
     # @return [String] path to the libmockspotify C extension binary.
     def self.path
-      File.expand_path('../mockspotify/libmockspotify.', __FILE__) << Config::MAKEFILE_CONFIG['DLEXT']
+      File.expand_path('../mockspotify/libmockspotify.', __FILE__) << RbConfig::MAKEFILE_CONFIG['DLEXT']
     end
 
     # Overridden to always ffi_lib the mock path.
@@ -25,23 +25,48 @@ module Spotify
   extend Mock
   require 'spotify'
 
+  module Mock
+    class PlaylistTrack < FFI::Struct
+      layout :track, :pointer,
+             :create_time, :int,
+             :creator, :pointer,
+             :message, :pointer,
+             :seen, :bool
+    end
+  end
+
   old_verbose, $VERBOSE = $VERBOSE, true
 
+  def self.attach_mock_function(name, cname, params, returns, options = {})
+    attach_function(name, cname, params, returns, options)
+    old_method = method(name)
+    define_singleton_method(name) do |*args|
+      Spotify::Pointer.new(old_method[*args], returns, false)
+    end
+  end
+
   attach_function :registry_find, [:string], :pointer
   attach_function :registry_add, [:string, :pointer], :void
+  attach_function :registry_clean, [], :void
 
-  attach_function :mock_session, :mocksp_session_create, [:pointer, :connectionstate, :int, :array, :int, Spotify::OfflineSyncStatus, :int, :int], :session
-  attach_function :mock_user, :mocksp_user_create, [:string, :string, :string, :string, :relation_type, :bool], :user
-  attach_function :mock_track, :mocksp_track_create, [:string, :int, :array, :album, :int, :int, :int, :int, :error, :bool, :bool, :bool, :bool, :bool], :track
-  attach_function :mock_image, :mocksp_image_create, [:image_id, :imageformat, :size_t, :buffer_in, :error], :image
-  attach_function :mock_artist, :mocksp_artist_create, [:string, :bool], :artist
-  attach_function :mock_album, :mocksp_album_create, [:string, :artist, :int, :image_id, :albumtype, :bool, :bool], :album
+  attach_function :mock_session, :mocksp_session_create, [:pointer, :connectionstate, :int, Spotify::OfflineSyncStatus, :int, :int, :playlist], :session
+  attach_mock_function :mock_user, :mocksp_user_create, [:string, :string, :bool], :user
+  attach_mock_function :mock_track, :mocksp_track_create, [:string, :int, :array, :album, :int, :int, :int, :int, :error, :bool, :availability, :track_offline_status, :bool, :bool, :bool, :bool], :track
+  attach_mock_function :mock_image, :mocksp_image_create, [:image_id, :imageformat, :size_t, :buffer_in, :error], :image
+  attach_mock_function :mock_artist, :mocksp_artist_create, [:string, :image_id, :bool], :artist
+  attach_mock_function :mock_album, :mocksp_album_create, [:string, :artist, :int, :image_id, :albumtype, :bool, :bool], :album
 
-  attach_function :mock_albumbrowse, :mocksp_albumbrowse_create, [:error, :album, :artist, :int, :array, :int, :array, :string, :albumbrowse_complete_cb, :pointer], :albumbrowse
-  attach_function :mock_artistbrowse, :mocksp_artistbrowse_create, [:error, :artist, :int, :array, :int, :array, :int, :array, :int, :array, :string, :artistbrowse_complete_cb, :pointer], :artistbrowse
-  attach_function :mock_toplistbrowse, :mocksp_toplistbrowse_create, [:error, :int, :array, :int, :array, :int, :array], :toplistbrowse
+  attach_function :mock_albumbrowse, :mocksp_albumbrowse_create, [:error, :int, :album, :artist, :int, :array, :int, :array, :string, :albumbrowse_complete_cb, :pointer], :albumbrowse
+  attach_function :mock_artistbrowse, :mocksp_artistbrowse_create, [:error, :int, :artist, :int, :array, :int, :array, :int, :array, :int, :array, :string, :artistbrowse_type, :artistbrowse_complete_cb, :pointer], :artistbrowse
+  attach_function :mock_toplistbrowse, :mocksp_toplistbrowse_create, [:error, :int, :int, :array, :int, :array, :int, :array], :toplistbrowse
 
+  attach_mock_function :mock_playlist, :mocksp_playlist_create, [:string, :bool, :user, :bool, :string, :image_id, :bool, :uint, Spotify::Subscribers, :bool, :playlist_offline_status, :int, :int, :array], :playlist
+  attach_mock_function :mock_playlistcontainer, :mocksp_playlistcontainer_create, [:user, :bool], :playlistcontainer
   attach_function :mock_search, :mocksp_search_create, [:error, :string, :string, :int, :int, :array, :int, :int, :array, :int, :int, :array, :search_complete_cb, :pointer], :search
+  attach_function :mock_subscribers, :mocksp_subscribers, [:int, :array], Spotify::Subscribers
+
+  # mocked accessors
+  attach_function :mocksp_playlist_get_autolink_tracks, [:playlist], :bool
 
   $VERBOSE = old_verbose
 end

data/spec/mockspotify/mockspotify_spec.rb

@@ -25,6 +25,15 @@ describe Spotify::Mock do
     end
   end
 
+  describe "unregion" do
+    it "should convert an integer to the correct region" do
+      Spotify.attach_function :unregion, [ :int ], :string
+
+      sweden = 21317
+      Spotify.unregion(sweden).should eq "SE"
+    end
+  end
+
   describe "the registry" do
     it "should find previously added entries" do
       Spotify.registry_add("i_exist", FFI::Pointer.new(1))
@@ -37,5 +46,18 @@ describe Spotify::Mock do
     it "should return nil for entries not in the registry" do
       Spotify.registry_find("i_do_not_exist").should be_null
     end
+
+    it "should be cleanable" do
+      pointer = FFI::MemoryPointer.new(:uint)
+
+      Spotify.registry_add("i_exist", pointer)
+      Spotify.registry_find("i_exist").should_not be_null
+
+      Spotify.registry_clean
+      Spotify.registry_find("i_exist").should be_null
+
+      Spotify.registry_add("i_exist", pointer)
+      Spotify.registry_find("i_exist").should_not be_null
+    end
   end
 end

data/spec/spec_helper.rb

@@ -16,6 +16,10 @@ Thread.abort_on_exception = true
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
 
+  config.before do
+    Hallon::Session.stub(:instance?).and_return(true)
+  end
+
   def fixture_image_path
     File.expand_path('../fixtures/pink_cover.jpg', __FILE__)
   end
@@ -26,11 +30,11 @@ RSpec.configure do |config|
   end
 
   def instantiate(klass, *pointers)
-    pointers.map { |x| klass.new(x) }
+    pointers.map { |x| klass.new(*x) }
   end
 
-  def mock_session
-    Hallon::Session.should_receive(:instance).at_least(1).times.and_return(session)
+  def mock_session(times = 1)
+    Hallon::Session.should_receive(:instance).at_least(times).times.and_return(session)
     yield
   end