hallon 0.11.0 → 0.12.0

data/spec/hallon/hallon_spec.rb

@@ -18,22 +18,4 @@ describe Hallon do
       it { should match uri }
     end
   end
-
-  describe "object callbacks" do
-    pending <<-REASON
-
-      Once callbacks are implemented in libmockspotify, we should also
-      test them on the following objects:
-
-      - Session
-      - Image
-      - AlbumBrowse
-      - ArtistBrowse
-      - Search
-      - Playlist
-      - PlaylistContainer
-      - Toplist
-      - Inbox
-    REASON
-  end
 end

data/spec/hallon/image_spec.rb

@@ -6,7 +6,6 @@ describe Hallon::Image do
     let(:spotify_uri) { "spotify:image:#{mock_image_hex}" }
     let(:custom_object) { mock_image_hex }
 
-
     let(:described_class) do
       real_session = session
       Hallon::Image.dup.tap do |klass|

data/spec/hallon/link_spec.rb

@@ -101,4 +101,18 @@ describe Hallon::Link do
       subject.should eq object
     end
   end
+
+  describe "#pointer" do
+    it "should raise an error if the expected type is not the same as requested" do
+      expect { Hallon::Link.new("spotify:user:burgestrand:starred").pointer(:profile) }.to raise_error(ArgumentError)
+    end
+
+    it "should not raise an error if the expected type is :playlist but real type is starred" do
+      expect { Hallon::Link.new("spotify:user:burgestrand:starred").pointer(:playlist) }.to_not raise_error
+    end
+
+    it "should not raise an error if the expected type and type matches" do
+      expect { Hallon::Link.new("spotify:user:burgestrand").pointer(:profile) }.to_not raise_error
+    end
+  end
 end

data/spec/hallon/observable/album_browse_spec.rb

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

data/spec/hallon/observable/artist_browse_spec.rb

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

data/spec/hallon/observable/image_spec.rb

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

data/spec/hallon/observable/playlist_container_spec.rb

@@ -0,0 +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] }
+  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] }
+  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] }
+  end
+
+  specification_for_callback "container_loaded" do
+    let(:input)  { [a_pointer, :userdata] }
+    let(:output) { [subject] }
+  end
+end

data/spec/hallon/observable/playlist_spec.rb

@@ -0,0 +1,85 @@
+describe Hallon::Observable::Playlist do
+  let(:trackpointers_size) { 2 }
+  let(:trackpointers) do
+    tracks = FFI::MemoryPointer.new(:pointer, 2)
+    tracks.write_array_of_pointer([mock_track, mock_track_two])
+    tracks
+  end
+
+  let(:tracks) do
+    instantiate(Hallon::Track, mock_track, mock_track_two)
+  end
+
+  specification_for_callback "tracks_added" do
+    let(:input)  { [a_pointer, trackpointers, trackpointers_size, 0, :userdata] }
+    let(:output) { [tracks, 0, subject] }
+  end
+
+  specification_for_callback "tracks_removed" do
+    let(:input)  { [a_pointer, trackpointers, trackpointers_size, :userdata] }
+    let(:output) { [tracks, subject] }
+  end
+
+  specification_for_callback "tracks_moved" do
+    let(:input)  { [a_pointer, trackpointers, trackpointers_size, 7, :userdata] }
+    let(:output) { [tracks, 7, subject] }
+  end
+
+  specification_for_callback "playlist_renamed" do
+    let(:input)  { [a_pointer, :userdata] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "playlist_state_changed" do
+    let(:input)  { [a_pointer, :userdata] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "playlist_update_in_progress" do
+    let(:input)  { [a_pointer, true, :userdata] }
+    let(:output) { [true, subject] }
+  end
+
+  specification_for_callback "playlist_metadata_updated" do
+    let(:input)  { [a_pointer, :userdata] }
+    let(:output) { [subject] }
+  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] }
+  end
+
+  specification_for_callback "track_seen_changed" do
+    let(:input)  { [a_pointer, 0, true, :userdata] }
+    let(:output) { [0, true, subject] }
+  end
+
+  specification_for_callback "track_message_changed" do
+    let(:input)  { [a_pointer, 13, "I LUFF JOO!", :userdata] }
+    let(:output) { [13, "I LUFF JOO!", subject] }
+  end
+
+  specification_for_callback "description_changed" do
+    let(:input)  { [a_pointer, "Merily merily merily bong", :userdata] }
+    let(:output) { ["Merily merily merily bong", subject] }
+  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] }
+
+    it "should not fail if the image has been *removed*" do
+      block = proc { |image| }
+      block.should_receive(:call).with(nil, subject)
+      subject.on(:image_changed, &block)
+      subject_callback.call(a_pointer, null_pointer, :userdata)
+    end
+  end
+
+  specification_for_callback "subscribers_changed" do
+    let(:input)  { [a_pointer, :userdata] }
+    let(:output) { [subject] }
+  end
+end

data/spec/hallon/observable/post_spec.rb

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

data/spec/hallon/observable/search_spec.rb

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

data/spec/hallon/observable/session_spec.rb

@@ -0,0 +1,143 @@
+# coding: utf-8
+describe Hallon::Observable::Session do
+  let(:klass) { Class.new { include described_class } }
+  let(:object) { klass.new }
+
+  specification_for_callback "logged_in" do
+    let(:input)  { [a_pointer, :ok] }
+    let(:output) { [:ok, subject] }
+  end
+
+  specification_for_callback "logged_out" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "metadata_updated" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "connection_error" do
+    let(:input)  { [a_pointer, :ok] }
+    let(:output) { [:ok, subject] }
+  end
+
+  specification_for_callback "message_to_user" do
+    let(:input)  { [a_pointer, "ALL UR BASE"] }
+    let(:output) { ["ALL UR BASE", subject] }
+  end
+
+  specification_for_callback "notify_main_thread" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "music_delivery" do
+    let(:num_frames) do
+      data.size / 2
+    end
+
+    let(:data) do
+      (0...100).zip((0...100).to_a.reverse).flatten # [0, 99, 1, 98 …]
+    end
+
+    let(:frames) do
+      channels = 2
+      frames = FFI::MemoryPointer.new(:int16, num_frames * channels)
+      frames.write_array_of_int16(data.flatten)
+      frames
+    end
+
+    let(:format) do
+      struct = Spotify::AudioFormat.new
+      struct[:sample_type] = :int16
+      struct[:sample_rate] = 44100 # 44.1khz
+      struct[:channels]    = 2
+      struct.pointer
+    end
+
+    let(:input)  { [a_pointer, format, frames, num_frames] }
+    let(:output) { [{rate: 44100, type: :int16, channels: 2}, data.each_slice(2), subject] }
+
+    it "should return the resulting value" do
+      subject.on(:music_delivery) { 7 }
+      subject_callback.call(*input).should eq 7
+    end
+
+    it "should ensure the resulting value is an integer" do
+      subject_callback.call(*input).should eq 0
+    end
+  end
+
+  specification_for_callback "play_token_lost" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "end_of_track" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "start_playback" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "stop_playback" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "get_audio_buffer_stats" do
+    let(:input)  { [a_pointer, Spotify::AudioBufferStats.new.pointer] }
+    let(:output) { [subject] }
+
+    it "should return the resulting audio buffer stats" do
+      stats = Spotify::AudioBufferStats.new
+      subject.on(:get_audio_buffer_stats) { [5, 7] }
+
+      stats[:samples].should eq 0
+      stats[:stutter].should eq 0
+      subject_callback.call(a_pointer, stats.pointer)
+      stats[:samples].should eq 5
+      stats[:stutter].should eq 7
+    end
+
+    it "should report zeroes if there’s no callback" do
+      stats = Spotify::AudioBufferStats.new
+
+      stats[:samples].should eq 0
+      stats[:stutter].should eq 0
+      subject_callback.call(a_pointer, stats.pointer)
+      stats[:samples].should eq 0
+      stats[:stutter].should eq 0
+    end
+  end
+
+  specification_for_callback "streaming_error" do
+    let(:input)  { [a_pointer, :ok] }
+    let(:output) { [:ok, subject] }
+  end
+
+  specification_for_callback "userinfo_updated" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "log_message" do
+    let(:input)  { [a_pointer, "WATCHING U!"] }
+    let(:output) { ["WATCHING U!", subject] }
+  end
+
+  specification_for_callback "offline_status_updated" do
+    let(:input)  { [a_pointer] }
+    let(:output) { [subject] }
+  end
+
+  specification_for_callback "offline_error" do
+    let(:input)  { [a_pointer, :ok] }
+    let(:output) { [:ok, subject] }
+  end
+end

data/spec/hallon/observable/toplist_spec.rb

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

data/spec/hallon/observable_spec.rb

@@ -1,80 +1,155 @@
+# coding: utf-8
 describe Hallon::Observable do
-  subject do
-    Class.new { include Hallon::Observable }.new
+  let(:klass) do
+    Class.new do
+      class << self
+        def initialize_callbacks
+          %w[testing testing_string testing_symbol testing_arguments].map do |m|
+            callback_for(m)
+          end
+        end
+
+        def testing_callback(pointer)
+          trigger(pointer, :testing)
+        end
+
+        def testing_string_callback(pointer)
+          trigger(pointer, "testing_string")
+        end
+
+        def testing_symbol_callback(pointer)
+          trigger(pointer, :testing_symbol)
+        end
+
+        def testing_arguments_callback(pointer, x, y)
+          trigger(pointer, :testing_arguments, x * 2, y * 4)
+        end
+      end
+
+      include Hallon::Observable
+
+      attr_reader :callbacks
+
+      def initialize
+        subscribe_for_callbacks do |callbacks|
+          @callbacks = callbacks
+        end
+      end
+
+      def fire!(name, *args, &block)
+        ptr = FFI::Pointer.new(pointer)
+        cb = self.class.send(:callback_for, name)
+        cb.call(ptr, *args)
+      end
+
+      def pointer
+        FFI::Pointer.new(0xDEADBEEF)
+      end
+    end
   end
 
-  describe "instance methods" do
-    it { should respond_to :on }
-    it { should respond_to :trigger }
+  describe "ClassMethods" do
+    subject { klass }
+
+    describe ".subscribers_for" do
+      around { |test| Ref::Mock.use(&test) }
+
+      it "should contain a list of weak references to subscribers" do
+        ptr = FFI::Pointer.new(0xDEADBEEF)
+
+        objA = klass.new
+        subject.subscribers_for(ptr).should eq [objA]
+
+        objB = klass.new
+        subject.subscribers_for(ptr).should eq [objA, objB]
+
+        Ref::Mock.gc(objA)
+        subject.subscribers_for(ptr).should eq [objB]
+      end
+
+      it "should return an empty array if there are no subscribers" do
+        subject.subscribers_for(null_pointer).should be_empty
+      end
+    end
   end
 
+  subject { klass.new }
+
   describe "#on" do
-    it "should allow defining one handler for multiple events" do
-      subject.on(:a, :b, :c) do |event, *args|
-        "yay"
-      end
+    it "should take both a symbol and a string" do
+      string = false
+      symbol = false
+
+      subject.on("testing_string") { string = true }
+      subject.on(:testing_symbol) { symbol = true }
+
+      subject.fire!(:testing_string)
+      subject.fire!("testing_symbol")
 
-      subject.trigger(:a).should eq "yay"
-      subject.trigger(:b).should eq "yay"
-      subject.trigger(:c).should eq "yay"
+      string.should be_true
+      symbol.should be_true
     end
 
-    specify "a multi-declared handler should know its name" do
-      subject.on(:a, :b) { |event, *args| event }
-      subject.trigger(:a).should eq :a
-      subject.trigger(:b).should eq :b
+    it "should receive the callback after it’s been processed" do
+      x = nil
+      y = nil
+
+      subject.on(:testing_arguments) do |a, b|
+        x = a
+        y = b
+      end
+
+      subject.fire!(:testing_arguments, 10, "Hi")
+
+      x.should eq 20
+      y.should eq "HiHiHiHi"
     end
 
-    specify "a single-declared handler should not know its name" do
-      subject.on(:a) { |event, *args| event }
-      subject.trigger(:a).should eq nil
+    it "should replace the previous callback if there was one" do
+      x = 0
+
+      subject.on(:testing) { x += 1 }
+      subject.fire!(:testing)
+      x.should eq 1
+
+      subject.on(:testing) { x -= 1 }
+      subject.fire!(:testing)
+      x.should eq 0
     end
 
-    it "should convert the event to a symbol" do
-      subject.on("a") { raise "hell" }
-      expect { subject.trigger(:a) }.to raise_error("hell")
+    it "should raise an error trying to bind to a non-existing callback" do
+      expect { subject.on("nonexisting") {} }.to raise_error(NameError)
     end
-  end
 
-  describe "#trigger and #on" do
-    it "should define and call event handlers" do
-      called = false
-      subject.on(:a) { called = true }
-      subject.trigger(:a)
-      called.should be_true
+    it "should raise an error when not given a block" do
+      expect { subject.on(:testing) }.to raise_error(ArgumentError)
     end
+  end
 
-    it "should pass any arguments to handlers" do
-      passed_args = []
-      subject.on(:a) { |*args| passed_args = args }
-      subject.trigger(:a, :b, :c)
-      passed_args.should eq [:b, :c]
+  describe "#subscribe_for_callbacks" do
+    it "should yield indiscriminetly" do
+      expect { subject.send(:subscribe_for_callbacks) }.to raise_error(LocalJumpError)
     end
 
-    it "should do nothing when there are no handlers" do
-      subject.trigger(:this_event_does_not_exist).should be_nil
+    it "should raise an error if the same object tries to subscribe twice" do
+      # we already subscribed for callbacks in initialize
+      expect { subject.send(:subscribe_for_callbacks) {} }.to raise_error(ArgumentError)
     end
 
-    context "multiple handlers" do
-      it "should call all handlers in order" do
-        triggered = []
-        subject.on(:a) { triggered << :a }
-        subject.on(:a) { triggered << :b }
-        subject.trigger(:a)
-        triggered.should eq [:a, :b]
-      end
+    it "should always yield the *same* object" do
+      a = klass.new
+      b = klass.new
 
-      it "should return the last-returned value" do
-        subject.on(:a) { :first }
-        subject.on(:a) { :second }
-        subject.trigger(:a).should eq :second
-      end
+      a.callbacks.should eq b.callbacks
+    end
+  end
 
-      it "should allow execution to be aborted" do
-        subject.on(:a) { throw :return, :first }
-        subject.on(:b) { :second }
-        subject.trigger(:a).should eq :first
-      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)
     end
   end
 
@@ -86,21 +161,15 @@ describe Hallon::Observable do
     end
 
     it "should restore previous handlers on return" do
-      subject.on(:protected) { "before" }
+      subject.on(:testing) { "before" }
 
       subject.protecting_handlers do
-        subject.trigger(:protected).should eq "before"
-        subject.on(:protected) { "after" }
-        subject.trigger(:protected).should eq "after"
+        subject.fire!(:testing).should eq "before"
+        subject.on(:testing) { "after" }
+        subject.fire!(:testing).should eq "after"
       end
 
-      subject.trigger(:protected).should eq "before"
-    end
-
-    it "should still allow #trigger to work on non-defined events" do
-      subject.protecting_handlers {}
-      expect { subject.trigger(:does_not_exist) }.to_not raise_error
+      subject.fire!(:testing).should eq "before"
     end
   end
-
 end