hallon 0.12.0 → 0.13.0

data/spec/hallon/error_spec.rb

@@ -42,8 +42,8 @@ describe Hallon::Error do
       subject.maybe_raise(nil).should eq nil
     end
 
-    it "should return nil when the error is timeout" do
-      subject.maybe_raise(:timeout).should eq nil
+    it "should return nil if the given symbol is also ignored" do
+      subject.maybe_raise(:is_loading, ignore: :is_loading).should eq nil
     end
   end
 

data/spec/hallon/image_spec.rb

@@ -47,12 +47,19 @@ describe Hallon::Image do
       end
     end
 
-    describe "#==" do
-      it "should not fail given an object that does not respond to id" do
+    describe "#===" do
+      it "should compare ids (but only if other is an Image)" do
+        other = double
+        other.should_receive(:is_a?).with(Hallon::Image).and_return(true)
+        other.should_receive(:id).with(true).and_return(image.id(true))
+
+        image.should === other
+        image.should_not === double
+      end
+
+      it "should not call #id if other is not an image" do
         o = Object.new
-        def o.id
-          raise NoMethodError
-        end
+        o.should_not_receive(:id)
 
         image.should_not eq o
       end

data/spec/hallon/link_spec.rb

@@ -77,17 +77,16 @@ describe Hallon::Link do
   end
 
   describe "#==" do
-    it "should compare using #to_str" do
-      obj = Object.new
-      obj.should_receive(:to_str).and_return(subject.to_str)
+    it "should compare using #to_str *if* other is a Link" do
+      objA = double
+      objA.should_not_receive(:to_str)
 
-      subject.should eq obj
-    end
+      objB = Hallon::Link.new(subject.to_str)
+      objB.should_receive(:pointer).and_return(null_pointer)
+      objB.should_receive(:to_str).and_return(subject.to_str)
 
-    it "should not fail when #to_str is unavailable" do
-      object = Object.new
-      object.should_not respond_to :to_str
-      subject.should_not eq object
+      subject.should_not eq objA
+      subject.should eq objB
     end
 
     it "should compare underlying pointers if #to_str is unavailable" do

data/spec/hallon/linkable_spec.rb

@@ -35,6 +35,17 @@ describe Hallon::Linkable do
     end
   end
 
+  describe "#to_str" do
+    it "should convert object to a link, and then to a string" do
+      link = mock
+      link.should_receive(:to_str).and_return("spotify:link")
+      object.should_receive(:to_link).and_return(link)
+
+      klass.instance_eval { to_link(:from_user) }
+      object.to_str.should eq "spotify:link"
+    end
+  end
+
   describe "#from_link" do
     it "should call the appropriate Spotify function" do
       Spotify.should_receive(:link_as_search!).and_return(pointer)

data/spec/hallon/observable/session_spec.rb

@@ -68,6 +68,10 @@ describe Hallon::Observable::Session do
     it "should ensure the resulting value is an integer" do
       subject_callback.call(*input).should eq 0
     end
+
+    it "should not go ballistic when there is no audio data" do
+      subject_callback.call(a_pointer, format, FFI::Pointer::NULL, 0)
+    end
   end
 
   specification_for_callback "play_token_lost" do

data/spec/hallon/player_spec.rb

@@ -1,6 +1,17 @@
+# coding: utf-8
 describe Hallon::Player do
-  let(:player) { Hallon::Player.new(session) }
-  let(:track) { Hallon::Track.new(mock_track) }
+  let(:player) { Hallon::Player.new(session, AudioDriverMock) }
+  let(:track)  { Hallon::Track.new(mock_track) }
+  let(:driver) { player.instance_variable_get('@driver') }
+  let(:queue)  { player.instance_variable_get('@queue') } # black box? WHAT?
+
+  describe "events" do
+    %w(end_of_track streaming_error play_token_lost).each do |e|
+      it "should support listening for #{e}" do
+        expect { player.on(e) {} }.to_not raise_error
+      end
+    end
+  end
 
   describe ".bitrates" do
     it "should be a list of symbols in ascending order" do
@@ -24,9 +35,14 @@ describe Hallon::Player do
       player.load(track)
     end
 
+    it "should try to instantiate the track if it’s not a track" do
+      Spotify.should_receive(:session_player_load).with(session.pointer, track.pointer)
+      player.load(track.to_str)
+    end
+
     it "should raise an error if load was unsuccessful" do
-      Spotify.should_receive(:session_player_load).and_return(:track_not_playable)
-      expect { player.load(track) }.to raise_error(Hallon::Error, /TRACK_NOT_PLAYABLE/)
+      Spotify.should_receive(:session_player_load).and_return(:is_loading)
+      expect { player.load(track) }.to raise_error(Hallon::Error, /IS_LOADING/)
     end
   end
 
@@ -51,8 +67,8 @@ describe Hallon::Player do
     end
 
     it "should load and play given track if one was given" do
-      Spotify.should_receive(:session_player_load).with(session.pointer, track.pointer)
       Spotify.should_receive(:session_player_play).with(session.pointer, true)
+      player.should_receive(:load).with(track)
       player.play(track)
     end
   end
@@ -78,4 +94,101 @@ describe Hallon::Player do
       player.volume_normalization?.should be_true
     end
   end
+
+  context "playing audio" do
+    before { session.class.send(:public, :trigger) }
+
+    it "should correctly report the status to libspotify" do
+      queue.should_receive(:size).and_return(7)
+      driver.should_receive(:drops).and_return(19)
+      session.trigger(:get_audio_buffer_stats).should eq [7, 19]
+    end
+
+    it "should assume no drops in audio if driver does not support checking" do
+      driver.should_receive(:respond_to?).with(:drops).and_return(false)
+      driver.should_not_receive(:drops)
+      session.trigger(:get_audio_buffer_stats).should eq [0, 0]
+    end
+
+    it "should tell the driver to start playback when commanded so by libspotify" do
+      driver.should_receive(:play)
+      session.trigger(:start_playback)
+    end
+
+    it "should tell the driver to stop playback when commanded so by libspotify" do
+      driver.should_receive(:pause)
+      session.trigger(:stop_playback)
+    end
+
+    it "should tell the driver to pause when pause is requested" do
+      driver.should_receive(:pause)
+      player.pause
+    end
+
+    it "should tell the driver to stop when stop is requested" do
+      queue.should_receive(:clear)
+      driver.should_receive(:stop)
+      player.stop
+    end
+
+    it "should not set the format on music delivery if it’s the same" do
+      queue.should_not_receive(:format=)
+      session.trigger(:music_delivery, queue.format, [1, 2, 3])
+    end
+
+    it "should set the format on music delivery if format changes" do
+      queue.should_receive(:format=).with(:new_format)
+      session.trigger(:music_delivery, :new_format, [1, 2, 3])
+    end
+
+    # why? it says so in the docs!
+    it "should clear the audio queue when receiving 0 audio frames" do
+      queue.should_receive(:clear)
+      session.trigger(:music_delivery, driver.format, [])
+    end
+
+    context "the output streaming" do
+      it "should feed music to the output stream if the format stays the same" do
+        Thread.stub(:start).and_return{ |*args, block| block[*args] }
+
+        player # create the Player
+        session.trigger(:music_delivery, queue.format, [1, 2, 3])
+
+        # it should block while player is stopped
+        begin
+          player.status.should be :stopped
+          Timeout::timeout(0.1) { driver.stream.call and "call was not blocking" }
+        rescue
+          :timeout
+        end.should eq :timeout
+
+        session.trigger(:start_playback)
+        player.status.should be :playing
+        driver.stream.call(1).should eq [1]
+        driver.stream.call(nil).should eq [2, 3]
+      end
+
+      it "should set the driver format and return no audio if audio format has changed" do
+        Thread.stub(:start).and_return{ |*args, block| block[*args] }
+
+        player # create the Player
+        session.trigger(:start_playback)
+        session.trigger(:music_delivery, :new_format, [1, 2, 3])
+
+        driver.should_receive(:format=).with(:new_format)
+        driver.stream.call.should be_nil
+
+        # driver.should_not_receive(:format)
+        driver.should_receive(:format).and_return(:new_format)
+        driver.stream.call.should eq [1, 2, 3]
+      end
+
+      it "should set the format on initialization" do
+        Thread.stub(:start).and_return{ |*args, block| block[*args] }
+        AudioDriverMock.any_instance.should_receive(:format=)
+        Hallon::AudioQueue.any_instance.should_receive(:format=)
+        player
+      end
+    end
+  end
 end

data/spec/hallon/playlist_container_spec.rb

@@ -152,12 +152,12 @@ describe Hallon::PlaylistContainer do
     end
 
     it "should support retrieving folders from their start" do
-      folder = Hallon::PlaylistContainer::Folder.new(container, 1..3)
+      folder = Hallon::PlaylistContainer::Folder.new(container.pointer, 1..3)
       container.contents[1].should eq folder
     end
 
     it "should support retrieving folders from their end" do
-      folder = Hallon::PlaylistContainer::Folder.new(container, 1..3)
+      folder = Hallon::PlaylistContainer::Folder.new(container.pointer, 1..3)
       container.contents[3].should eq folder
     end
   end

data/spec/hallon/playlist_spec.rb

@@ -4,35 +4,30 @@ require 'time'
 describe Hallon::Playlist do
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi" }
-    let(:described_class) do
-      real_session = session
-      Hallon::Playlist.dup.tap do |klass|
-        klass.class_eval do
-          define_method(:session) { real_session }
-        end
-      end
-    end
+    let(:described_class) { Hallon::Playlist.tap { |o| stub_session(o.any_instance) } }
   end
 
-  let(:playlist) { Hallon::Playlist.new(mock_playlist) }
   subject { playlist }
+  let(:playlist) do
+    Hallon::Playlist.new(mock_playlist)
+  end
 
   it { should be_loaded }
   it { should be_collaborative }
   it { should_not be_pending }
-  it { mock_session { should be_in_ram } }
-  it { mock_session { should_not be_available_offline } }
+  it { stub_session { should be_in_ram } }
+  it { stub_session { should_not be_available_offline } }
 
   its(:name)  { should eq "Megaplaylist" }
   its(:owner) { should eq Hallon::User.new(mock_user) }
   its(:description) { should eq "Playlist description...?" }
-  its(:image) { mock_session { should eq Hallon::Image.new(mock_image_id) } }
+  its(:image) { stub_session { should eq Hallon::Image.new(mock_image_id) } }
   its(:total_subscribers) { should eq 1000 }
-  its(:sync_progress) { mock_session { should eq 67 } }
+  its(:sync_progress) { stub_session { should eq 67 } }
   its(:size) { should eq 4 }
 
   its('tracks.size') { should eq 4 }
-  its('tracks.to_a') { should eq instantiate(Hallon::Playlist::Track, *(0...4).map { |index| [Spotify.playlist_track!(playlist.pointer, index), playlist, index] }) }
+  its('tracks.to_a') { should eq instantiate(Hallon::Playlist::Track, *(0...4).map { |index| [Spotify.playlist_track!(playlist.pointer, index), playlist.pointer, index] }) }
 
   describe "tracks#[]" do
     let(:track) { subject }
@@ -83,24 +78,24 @@ describe Hallon::Playlist do
     end
   end
 
-  describe "#insert" do
+  describe "#insert", :stub_session do
     let(:tracks) { instantiate(Hallon::Track, mock_track, mock_track_two) }
 
     it "should add the given tracks to the playlist at correct index" do
       old_tracks = playlist.tracks.to_a
       new_tracks = old_tracks.insert(1, *tracks)
-      mock_session { playlist.insert(1, tracks) }
+      playlist.insert(1, tracks)
 
       playlist.tracks.to_a.should eq new_tracks
     end
 
     it "should default to adding tracks at the end" do
-      mock_session { playlist.insert(tracks) }
+      playlist.insert(tracks)
       playlist.tracks[2, 2].should eq tracks
     end
 
     it "should raise an error if the operation cannot be completed" do
-      expect { mock_session { playlist.insert(-1, nil) } }.to raise_error(Hallon::Error)
+      expect { playlist.insert(-1, nil) }.to raise_error(Hallon::Error)
     end
   end
 
@@ -169,55 +164,55 @@ describe Hallon::Playlist do
     end
   end
 
-  describe "#in_ram=" do
+  describe "#in_ram=", :stub_session do
     it "should set in_ram status" do
-      mock_session do
-        playlist.should be_in_ram
-        playlist.in_ram = false
-        playlist.should_not be_in_ram
-      end
+      playlist.should be_in_ram
+      playlist.in_ram = false
+      playlist.should_not be_in_ram
     end
   end
 
-  describe "#offline_mode=" do
+  describe "#offline_mode=", :stub_session do
     it "should set offline mode" do
-      mock_session do
-        playlist.should_not be_available_offline
-        playlist.offline_mode = true
-        playlist.should be_available_offline
-      end
+      playlist.should_not be_available_offline
+      playlist.offline_mode = true
+      playlist.should be_available_offline
     end
   end
 
-  describe "#update_subscribers" do
+  describe "#update_subscribers", :stub_session do
     it "should ask libspotify to update the subscribers" do
-      expect { mock_session { playlist.update_subscribers } }.to_not raise_error
+      expect { playlist.update_subscribers }.to_not raise_error
+    end
+
+    it "should return the playlist" do
+      playlist.update_subscribers.should eq playlist
     end
   end
 
-  describe "offline status methods" do
+  describe "offline status methods", :stub_session do
     def symbol_for(number)
       Spotify.enum_type(:playlist_offline_status)[number]
     end
 
     specify "#available_offline?" do
       Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(1)
-      mock_session { should be_available_offline }
+      should be_available_offline
     end
 
     specify "#syncing?" do
       Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(2)
-      mock_session { should be_syncing }
+      should be_syncing
     end
 
     specify "#waiting?" do
       Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(3)
-      mock_session { should be_waiting }
+      should be_waiting
     end
 
     specify "#offline_mode?" do
       Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(0)
-      mock_session { should_not be_offline_mode }
+      should_not be_offline_mode
     end
   end
 end

data/spec/hallon/search_spec.rb

@@ -69,15 +69,15 @@ describe Hallon::Search do
 
   its('tracks.size')  { should eq 2 }
   its('tracks.to_a')  { should eq instantiate(Hallon::Track, mock_track, mock_track_two) }
-  its('total_tracks') { should eq 1337 }
+  its('tracks.total') { should eq 1337 }
 
   its('albums.size')  { should eq 1 }
   its('albums.to_a')  { should eq instantiate(Hallon::Album, mock_album) }
-  its('total_albums') { should eq 42 }
+  its('albums.total') { should eq 42 }
 
   its('artists.size')  { should eq 2 }
   its('artists.to_a')  { should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two) }
-  its('total_artists') { should eq 81104 }
+  its('artists.total') { should eq 81104 }
 
   its(:to_link) { should eq Hallon::Link.new("spotify:search:#{search.query}") }
 end

data/spec/hallon/user_spec.rb

@@ -14,12 +14,6 @@ describe Hallon::User do
       end
     end
 
-    describe "#to_link" do
-      it "should return a Link for this user" do
-        user.to_link.should eq "spotify:user:burgestrand"
-      end
-    end
-
     describe "#name" do
       it "should be the canonical name" do
         user.name.should eq "burgestrand"

data/spec/spec_helper.rb

@@ -37,6 +37,16 @@ RSpec.configure do |config|
     yield
   end
 
+  def stub_session(target = nil)
+    if target
+      target.stub(:session).and_return(session)
+    else
+      Hallon::Session.stub(:instance).and_return(session)
+    end
+
+    target.tap { yield if block_given? }
+  end
+
   def pointer_array_with(*args)
     ary = FFI::MemoryPointer.new(:pointer, args.size)
     ary.write_array_of_pointer args