hallon 0.15.0 → 0.16.0

data/spec/hallon/link_spec.rb

@@ -1,69 +1,77 @@
 describe Hallon::Link do
-  subject { Hallon::Link.new("spotify:user:burgestrand") }
+  let(:link) do
+    Hallon::Link.new("spotify:user:burgestrand")
+  end
 
-  context "class methods" do
-    describe "::new" do
-      it "should raise an ArgumentError on an invalid link" do
-        expect { Hallon::Link.new("omgwtfbbq") }.to raise_error(ArgumentError, /omgwtfbbq/)
-      end
+  describe ".new" do
+    it "should raise an ArgumentError on an invalid link" do
+      expect { Hallon::Link.new("omgwtfbbq") }.to raise_error(ArgumentError, /omgwtfbbq/)
+    end
 
-      it "should not raise error on valid links" do
-        expect { Hallon::Link.new("spotify:user:burgestrand") }.to_not raise_error
-      end
+    it "should not raise error on valid links" do
+      expect { Hallon::Link.new("spotify:user:burgestrand") }.to_not raise_error
+    end
 
-      it "should raise an error given a null pointer" do
-        expect { Hallon::Link.new(Spotify::Pointer.new(null_pointer, :link, false)) }.to raise_error(ArgumentError)
-      end
+    it "should raise an error given a null pointer" do
+      expect { Hallon::Link.new(Spotify::Pointer.new(null_pointer, :link, false)) }.to raise_error(ArgumentError)
+    end
 
-      it "should raise an error when no session instance is about" do
-        # this is due to a bug in libspotify, it will segfault otherwise
-        Hallon::Session.stub(:instance?).and_return(false)
-        expect { Hallon::Link.new("spotify:user:burgestrand") }.to raise_error(/session/i)
-      end
+    it "should raise an error when no session instance is about" do
+      # this is due to a bug in libspotify, it will segfault otherwise
+      Hallon::Session.stub(:instance?).and_return(false)
+      expect { Hallon::Link.new("spotify:user:burgestrand") }.to raise_error(Hallon::NoSessionError)
+    end
 
-      it "should accept any object that supplies a #to_link method" do
-        link = Hallon::Link.new("spotify:user:burgestrand")
+    it "should accept any object that supplies a #to_link method" do
+      link = Hallon::Link.new("spotify:user:burgestrand")
 
-        to_linkable = double
-        to_linkable.should_receive(:to_link).and_return(link)
+      to_linkable = double
+      to_linkable.should_receive(:to_link).and_return(link)
 
-        Hallon::Link.new(to_linkable).should eq link
-      end
+      Hallon::Link.new(to_linkable).should eq link
     end
+  end
 
-    describe "::valid?" do
-      it "should be true for a valid link" do
-        Hallon::Link.valid?("spotify:user:burgestrand").should be_true
-      end
+  describe ".valid?" do
+    it "should be true for a valid link" do
+      Hallon::Link.valid?("spotify:user:burgestrand").should be_true
+    end
 
-      it "should be false for an invalid link" do
-        Hallon::Link.valid?("omgwtfbbq").should be_false
-      end
+    it "should be false for an invalid link" do
+      Hallon::Link.valid?("omgwtfbbq").should be_false
+    end
+
+    it "raises an error when no session has been initialized" do
+      # this is due to a bug in libspotify, it will segfault otherwise
+      Hallon::Session.stub(:instance?).and_return(false)
+      expect { Hallon::Link.valid?("omgwtfbbq") }.to raise_error(Hallon::NoSessionError)
     end
   end
 
   describe "#to_str" do
     it "should return the Spotify URI as a string" do
-      subject.to_str.should == "spotify:user:burgestrand"
+      link.to_str.should == "spotify:user:burgestrand"
     end
 
     it "should truncate if given a small maximum length" do
-      subject.to_str(7).should == "spotify"
+      link.to_str(7).should == "spotify"
     end
 
     it "should be in UTF-8 encoding" do
-      subject.to_str.encoding.should eq Encoding::UTF_8
+      link.to_str.encoding.should eq Encoding::UTF_8
     end
   end
 
   describe "#to_url" do
     it "should return the correct http URL" do
-      subject.to_url.should == "http://open.spotify.com/user/burgestrand"
+      link.to_url.should == "http://open.spotify.com/user/burgestrand"
     end
   end
 
   describe "#length" do
-    it { subject.length.should == "spotify:user:burgestrand".length }
+    it "returns the image length" do
+      link.length.should == "spotify:user:burgestrand".length
+    end
   end
 
   describe "#type" do
@@ -75,8 +83,8 @@ describe Hallon::Link do
   end
 
   describe "#to_s" do
-    it("should include the Spotify URI") do
-      subject.to_s.should include subject.to_str
+    it "includes the image URI" do
+      link.to_s.should include link.to_uri
     end
   end
 
@@ -85,23 +93,23 @@ describe Hallon::Link do
       objA = double
       objA.should_not_receive(:to_str)
 
-      objB = Hallon::Link.new(subject.to_str)
+      objB = Hallon::Link.new(link.to_str)
       objB.should_receive(:pointer).and_return(null_pointer)
-      objB.should_receive(:to_str).and_return(subject.to_str)
+      objB.should_receive(:to_str).and_return(link.to_str)
 
-      subject.should_not eq objA
-      subject.should eq objB
+      link.should_not eq objA
+      link.should eq objB
     end
 
     it "should compare underlying pointers if #to_str is unavailable" do
-      object = Hallon::Link.new(subject.pointer)
+      object = Hallon::Link.new(link.pointer)
 
       def object.respond_to?(o)
         return false if o == :to_str
         super
       end
 
-      subject.should eq object
+      link.should eq object
     end
   end
 

data/spec/hallon/observable/album_browse_spec.rb

@@ -2,6 +2,6 @@ describe Hallon::Observable::AlbumBrowse do
   specification_for_callback "load" do
     let(:type)   { :albumbrowse_complete_cb }
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 end

data/spec/hallon/observable/artist_browse_spec.rb

@@ -2,6 +2,6 @@ describe Hallon::Observable::ArtistBrowse do
   specification_for_callback "load" do
     let(:type)   { :artistbrowse_complete_cb }
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 end

data/spec/hallon/observable/image_spec.rb

@@ -2,7 +2,7 @@ describe Hallon::Observable::Image do
   specification_for_callback "load" do
     let(:type)   { :image_loaded_cb }
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 end
 

data/spec/hallon/observable/playlist_container_spec.rb

@@ -1,21 +1,21 @@
 describe Hallon::Observable::PlaylistContainer do
   specification_for_callback "playlist_added" do
     let(:input)  { [a_pointer, mock_playlist_raw, 3, :userdata] }
-    let(:output) { [Hallon::Playlist.new(mock_playlist), 3, subject] }
+    let(:output) { [Hallon::Playlist.new(mock_playlist), 3] }
   end
 
   specification_for_callback "playlist_removed" do
     let(:input)  { [a_pointer, mock_playlist_raw, 3, :userdata] }
-    let(:output) { [Hallon::Playlist.new(mock_playlist), 3, subject] }
+    let(:output) { [Hallon::Playlist.new(mock_playlist), 3] }
   end
 
   specification_for_callback "playlist_moved" do
     let(:input)  { [a_pointer, mock_playlist_raw, 3, 8, :userdata] }
-    let(:output) { [Hallon::Playlist.new(mock_playlist), 3, 8, subject] }
+    let(:output) { [Hallon::Playlist.new(mock_playlist), 3, 8] }
   end
 
   specification_for_callback "container_loaded" do
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 end

data/spec/hallon/observable/playlist_spec.rb

@@ -18,67 +18,67 @@ describe Hallon::Observable::Playlist do
 
   specification_for_callback "tracks_added" do
     let(:input)  { [a_pointer, trackpointers, trackpointers_size, 0, :userdata] }
-    let(:output) { [tracks, 0, subject] }
+    let(:output) { [tracks, 0] }
   end
 
   specification_for_callback "tracks_removed" do
     let(:input)  { [a_pointer, track_index_pointers, trackpointers_size, :userdata] }
-    let(:output) { [[0, 1], subject] }
+    let(:output) { [[0, 1]] }
   end
 
   specification_for_callback "tracks_moved" do
     let(:input)  { [a_pointer, track_index_pointers, trackpointers_size, 7, :userdata] }
-    let(:output) { [[0, 1], 7, subject] }
+    let(:output) { [[0, 1], 7] }
   end
 
   specification_for_callback "playlist_renamed" do
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "playlist_state_changed" do
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "playlist_update_in_progress" do
     let(:input)  { [a_pointer, true, :userdata] }
-    let(:output) { [true, subject] }
+    let(:output) { [true] }
   end
 
   specification_for_callback "playlist_metadata_updated" do
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "track_created_changed" do
     let(:input)  { [a_pointer, 7, mock_user_raw, 15, :userdata] }
-    let(:output) { [7, Hallon::User.new(mock_user), Time.at(15), subject] }
+    let(:output) { [7, Hallon::User.new(mock_user), Time.at(15)] }
   end
 
   specification_for_callback "track_seen_changed" do
     let(:input)  { [a_pointer, 0, true, :userdata] }
-    let(:output) { [0, true, subject] }
+    let(:output) { [0, true] }
   end
 
   specification_for_callback "track_message_changed" do
     let(:input)  { [a_pointer, 13, "I LUFF JOO!", :userdata] }
-    let(:output) { [13, "I LUFF JOO!", subject] }
+    let(:output) { [13, "I LUFF JOO!"] }
   end
 
   specification_for_callback "description_changed" do
     let(:input)  { [a_pointer, "Merily merily merily bong", :userdata] }
-    let(:output) { ["Merily merily merily bong", subject] }
+    let(:output) { ["Merily merily merily bong"] }
   end
 
   specification_for_callback "image_changed" do
     before { Hallon::Session.stub!(:instance => session) }
     let(:input)  { [a_pointer, mock_image_id, :userdata] }
-    let(:output) { [Hallon::Image.new(mock_image), subject] }
+    let(:output) { [Hallon::Image.new(mock_image)] }
 
     it "should not fail if the image has been *removed*" do
       block = proc { |image| }
-      block.should_receive(:call).with(nil, subject)
+      block.should_receive(:call).with(nil)
       subject.on(:image_changed, &block)
       subject_callback.call(a_pointer, null_pointer, :userdata)
     end
@@ -86,6 +86,6 @@ describe Hallon::Observable::Playlist do
 
   specification_for_callback "subscribers_changed" do
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 end

data/spec/hallon/observable/post_spec.rb

@@ -2,7 +2,7 @@ describe Hallon::Observable::Post do
   specification_for_callback "complete" do
     let(:type)   { :inboxpost_complete_cb }
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 end
 

data/spec/hallon/observable/search_spec.rb

@@ -2,6 +2,6 @@ describe Hallon::Observable::Search do
   specification_for_callback "load" do
     let(:type)   { :search_complete_cb }
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 end

data/spec/hallon/observable/session_spec.rb

@@ -5,32 +5,32 @@ describe Hallon::Observable::Session do
 
   specification_for_callback "logged_in" do
     let(:input)  { [a_pointer, :ok] }
-    let(:output) { [:ok, subject] }
+    let(:output) { [:ok] }
   end
 
   specification_for_callback "logged_out" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "metadata_updated" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "connection_error" do
     let(:input)  { [a_pointer, :ok] }
-    let(:output) { [:ok, subject] }
+    let(:output) { [:ok] }
   end
 
   specification_for_callback "message_to_user" do
     let(:input)  { [a_pointer, "ALL UR BASE"] }
-    let(:output) { ["ALL UR BASE", subject] }
+    let(:output) { ["ALL UR BASE"] }
   end
 
   specification_for_callback "notify_main_thread" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "music_delivery" do
@@ -58,7 +58,7 @@ describe Hallon::Observable::Session do
     end
 
     let(:input)  { [a_pointer, format, frames, num_frames] }
-    let(:output) { [{rate: 44100, type: :int16, channels: 2}, data.each_slice(2), subject] }
+    let(:output) { [{rate: 44100, type: :int16, channels: 2}, data.each_slice(2)] }
 
     it "should return the resulting value" do
       subject.on(:music_delivery) { 7 }
@@ -76,27 +76,27 @@ describe Hallon::Observable::Session do
 
   specification_for_callback "play_token_lost" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "end_of_track" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "start_playback" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "stop_playback" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "get_audio_buffer_stats" do
     let(:input)  { [a_pointer, Spotify::AudioBufferStats.new.pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
 
     it "should return the resulting audio buffer stats" do
       stats = Spotify::AudioBufferStats.new
@@ -122,26 +122,26 @@ describe Hallon::Observable::Session do
 
   specification_for_callback "streaming_error" do
     let(:input)  { [a_pointer, :ok] }
-    let(:output) { [:ok, subject] }
+    let(:output) { [:ok] }
   end
 
   specification_for_callback "userinfo_updated" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "log_message" do
     let(:input)  { [a_pointer, "WATCHING U!"] }
-    let(:output) { ["WATCHING U!", subject] }
+    let(:output) { ["WATCHING U!"] }
   end
 
   specification_for_callback "offline_status_updated" do
     let(:input)  { [a_pointer] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 
   specification_for_callback "offline_error" do
     let(:input)  { [a_pointer, :ok] }
-    let(:output) { [:ok, subject] }
+    let(:output) { [:ok] }
   end
 end

data/spec/hallon/observable/toplist_spec.rb

@@ -2,6 +2,6 @@ describe Hallon::Observable::Toplist do
   specification_for_callback "load" do
     let(:type)   { :toplistbrowse_complete_cb }
     let(:input)  { [a_pointer, :userdata] }
-    let(:output) { [subject] }
+    let(:output) { [] }
   end
 end

data/spec/hallon/observable_spec.rb

@@ -45,6 +45,10 @@ describe Hallon::Observable do
       def pointer
         FFI::Pointer.new(0xDEADBEEF)
       end
+
+      def session
+        Hallon::Session.instance
+      end
     end
   end
 
@@ -159,12 +163,42 @@ describe Hallon::Observable do
     end
   end
 
-  describe "#trigger" do
-    it "should always append self to the arguments" do
-      block = proc {}
-      subject.on(:testing, &block)
-      block.should_receive(:call).with(subject)
-      subject.send(:trigger, :testing)
+  describe "#wait_for" do
+    around(:each) do |example|
+      Timeout.timeout(0.5, SlowTestError, &example)
+    end
+
+    it "should not call the given block on notify main thread event" do
+      notified = false
+      counter  = 0
+
+      session.should_receive(:process_events).twice.and_return do
+        if notified
+          subject.class.send(:testing_callback, subject.pointer)
+        else
+          session.class.send(:notify_main_thread_callback, session.pointer)
+          notified = true
+        end
+
+        0
+      end
+
+      subject.wait_for(:testing) do |event|
+        event.should eq :testing if (counter += 1) > 1
+      end
+    end
+
+    it "should time out if waiting for events too long" do
+      counter = 0
+      session.should_receive(:process_events).once.and_return(0) # and do nothing
+      subject.wait_for(:testing) do |event|
+        event.should be_nil if (counter += 1) > 1
+      end
+    end
+
+    it "should call the given block once before waiting" do
+      session.should_not_receive(:process_events)
+      subject.wait_for { true }
     end
   end