hallon 0.8.0 → 0.9.0

data/spec/hallon/album_spec.rb

@@ -1,16 +1,17 @@
 # coding: utf-8
 describe Hallon::Album do
-  subject { Hallon::Album.new(mock_album) }
+  it_should_behave_like "a Linkable object" do
+    let(:spotify_uri) { "spotify:album:1xvnWMz2PNFf7mXOSRuLws" }
+  end
+
+  let(:album) { Hallon::Album.new(mock_album) }
+  subject { album }
 
   its(:name) { should eq "Finally Woken" }
-  its(:year) { should be 2004 }
+  its(:release_year) { should be 2004 }
   its(:type) { should be :single }
-
   its(:browse) do
-    mock_session do
-      Spotify.should_receive(:albumbrowse_create).exactly(2).times.and_return(mock_albumbrowse)
-      should eq Hallon::AlbumBrowse.new(mock_album)
-    end
+    mock_session { should eq Hallon::AlbumBrowse.new(album) }
   end
 
   it { should be_available }
@@ -19,27 +20,26 @@ describe Hallon::Album do
   describe "artist" do
     it "should be nil if there is no artist" do
       Spotify.should_receive(:album_artist).and_return(null_pointer)
-      subject.artist.should be_nil
+      album.artist.should be_nil
     end
 
     it "should be an artist if it exists" do
-      subject.artist.should be_a Hallon::Artist
+      album.artist.should eq Hallon::Artist.new(mock_artist)
     end
   end
 
   describe "cover" do
     it "should be nil if there is no image" do
       Spotify.should_receive(:album_cover).and_return(null_pointer)
-      subject.cover.should be_nil
+      album.cover.should be_nil
     end
 
     it "should be an image if it exists" do
-      FFI::MemoryPointer.new(:string, 20) do |ptr|
-        ptr.write_string(mock_image_id)
+      mock_session { album.cover.id.should eq mock_image_hex }
+    end
 
-        Spotify.should_receive(:album_cover).and_return(ptr)
-        mock_session { subject.cover.id.should eq mock_image_hex }
-      end
+    it "should be a link if requested" do
+      album.cover(false).to_str.should eq "spotify:image:3ad93423add99766e02d563605c6e76ed2b0e450"
     end
   end
 

data/spec/hallon/artist_browse_spec.rb

@@ -1,22 +1,23 @@
 # coding: utf-8
 describe Hallon::ArtistBrowse do
-  subject do
-    mock_session do
-      artist = Hallon::Artist.new(mock_artist)
-      Spotify.should_receive(:artistbrowse_create).and_return(mock_artistbrowse)
-      Hallon::ArtistBrowse.new(artist)
-    end
+  let(:browse) do
+    artist = Hallon::Artist.new(mock_artist)
+    mock_session { Hallon::ArtistBrowse.new(artist) }
   end
 
+  subject { browse }
+
   it { should be_loaded }
-  its(:error)  { should eq :ok }
+  its(:status) { should eq :ok }
   its(:artist) { should eq Hallon::Artist.new(mock_artist) }
 
   its('portraits.size') { should eq 2 }
   its('portraits.to_a') do
-    Hallon::Session.should_receive(:instance).exactly(2).times.and_return(session)
+    mock_session(2) { subject.map{ |img| img.id(true) }.should eq [mock_image_id, mock_image_id] }
+  end
 
-    subject.map{ |img| img.id(true) }.should eq [mock_image_id, mock_image_id]
+  specify 'portraits(false)' do
+    browse.portraits(false)[0].should eq Hallon::Link.new(mock_image_link)
   end
 
   its('tracks.size') { should eq 2 }
@@ -26,4 +27,22 @@ describe Hallon::ArtistBrowse do
   its('similar_artists.size') { should eq 2 }
   its('similar_artists.to_a') { should eq [mock_artist, mock_artist_two].map{ |p| Hallon::Artist.new(p) } }
   its(:biography) { should eq 'grew up in DA BLOCK' }
+
+  describe "#request_duration" do
+    it "should return the request duration in seconds" do
+      browse.request_duration.should eq 2.751
+    end
+
+    it "should be nil if the request was fetched from local cache" do
+      Spotify.should_receive(:artistbrowse_backend_request_duration).and_return(-1)
+      browse.request_duration.should be_nil
+    end
+  end
+
+  describe '.types' do
+    subject { Hallon::ArtistBrowse.types }
+
+    it { should be_an Array }
+    it { should include :full }
+  end
 end

data/spec/hallon/artist_spec.rb

@@ -1,32 +1,48 @@
 # coding: utf-8
 describe Hallon::Artist do
-  subject { Hallon::Artist.new(mock_artist) }
+  it_should_behave_like "a Linkable object" do
+    let(:spotify_uri) { "spotify:artist:3bftcFwl4vqRNNORRsqm1G" }
+  end
+
+  let(:artist) { Hallon::Artist.new(mock_artist) }
+  subject { artist }
 
   it { should be_loaded }
   its(:name) { should eq "Jem" }
-  its(:browse) do
-    Hallon::Session.should_receive(:instance).exactly(2).times.and_return(session)
-    Spotify.should_receive(:artistbrowse_create).exactly(2).times.and_return(mock_artistbrowse)
 
-    should eq Hallon::ArtistBrowse.new(mock_artist)
-  end
+  describe "#browse" do
+    it "should return an artist browsing object" do
+      mock_session(2) { subject.browse.should eq Hallon::ArtistBrowse.new(mock_artist) }
+    end
 
-  describe "#portrait" do
-    let(:link) { Hallon::Link.new("spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663") }
-    let(:link_pointer) { FFI::Pointer.new(link.pointer.address) }
+    it "should default to full browsing" do
+      Hallon::ArtistBrowse.should_receive(:new).with(artist.pointer, :full)
+      artist.browse
+    end
 
-    before do
-      Hallon::Link.new(link_pointer).should eq link
-      Spotify.should_receive(:link_create_from_artist_portrait).with(subject.pointer).and_return(link_pointer)
+    it "should pass the browsing type along when creating the artist browsing object" do
+      Hallon::ArtistBrowse.should_receive(:new).with(artist.pointer, :no_tracks)
+      artist.browse(:no_tracks)
     end
+  end
+
+  describe "#portrait" do
+    let(:link) { Hallon::Link.new(mock_image_uri) }
 
     specify "as an image" do
       Hallon::Session.should_receive(:instance).twice.and_return(session)
-      subject.portrait.should eq Hallon::Image.new(link_pointer)
+
+      subject.portrait.should eq Hallon::Image.new(mock_image_id)
     end
 
     specify "as a link" do
-      subject.portrait(false).should eq link
+      subject.portrait(false).should eq Hallon::Link.new(mock_image_uri)
+    end
+
+    it "should be nil if an image is not available" do
+      Spotify.should_receive(:artist_portrait).and_return(null_pointer)
+
+      subject.portrait.should be_nil
     end
   end
 end

data/spec/hallon/enumerator_spec.rb

@@ -19,7 +19,6 @@ describe Hallon::Enumerator do
 
   describe "#each" do
     it "should call the containing block" do
-      calls = []
       enum = Hallon::Enumerator.new(4) { |i| item.get(i) }
       enum.each_with_index { |x, i| x.should eq alphabet[i] }
     end

data/spec/hallon/hallon_spec.rb

@@ -1,10 +1,11 @@
+# coding: utf-8
 describe Hallon do
   describe "VERSION" do
     specify { Hallon::VERSION.should be_a String }
   end
 
   describe "API_VERSION" do
-    specify { Hallon::API_VERSION.should == 9 }
+    specify { Hallon::API_VERSION.should == 10 }
   end
 
   describe "API_BUILD" do
@@ -17,4 +18,22 @@ 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

@@ -1,8 +1,25 @@
 # coding: utf-8
+require 'ostruct'
+
 describe Hallon::Image do
+  it_should_behave_like "a Linkable object" 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|
+        klass.class_eval do
+          define_method(:session) { real_session }
+        end
+      end
+    end
+  end
+
   describe "an image instance" do
     subject { image }
-    let(:image) { mock_session { Hallon::Image.new(mock_image) } }
+    let(:image) { Hallon::Image.new(mock_image) }
 
     it { should be_loaded }
     its(:status) { should be :ok }
@@ -21,7 +38,6 @@ describe Hallon::Image do
       end
 
       it "should have a binary encoding" do
-        pending "ruby 1.8 does not support String#encoding" unless subject.respond_to?(:encoding)
         subject.encoding.name.should eq 'ASCII-8BIT'
       end
     end
@@ -43,43 +59,4 @@ describe Hallon::Image do
       end
     end
   end
-
-  describe "instantiation" do
-    subject do
-      mock_session do
-        Hallon::Image.new(image_uri)
-      end
-    end
-
-    context "created from an url" do
-      let(:image_uri) { "http://open.spotify.com/image/c78f091482e555bd2ffacfcd9cbdc0714b221663" }
-      its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
-    end
-
-    context "created from an uri" do
-      let(:image_uri) { "spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663" }
-      its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
-    end
-
-    context "created from an id" do
-      let(:image_uri) { mock_image_id }
-      its(:id) { should eq mock_image_hex }
-    end
-
-    context "created from a link" do
-      let(:image_uri) { Hallon::Link.new("spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663") }
-      its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
-    end
-  end
-
-  describe "callbacks" do
-    it "should trigger :load when loaded", :pending => true do
-      uri = "spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663"
-      image = Hallon::Image.new(uri)
-      image.should_not be_loaded
-      image.should_receive(:trigger).with(:load).once
-
-      session.process_events_on { image.loaded? }
-    end
-  end
 end

data/spec/hallon/link_spec.rb

@@ -2,35 +2,33 @@ describe Hallon::Link do
   subject { Hallon::Link.new("spotify:user:burgestrand") }
 
   context "class methods" do
-    subject { described_class }
-
     describe "::new" do
       it "should raise an ArgumentError on an invalid link" do
-        expect { subject.new("omgwtfbbq") }.to raise_error(ArgumentError, /omgwtfbbq/)
+        expect { Hallon::Link.new("omgwtfbbq") }.to raise_error(ArgumentError, /omgwtfbbq/)
       end
 
       it "should not raise error on valid links" do
-        expect { subject.new("spotify:user:burgestrand") }.to_not raise_error
+        expect { Hallon::Link.new("spotify:user:burgestrand") }.to_not raise_error
       end
 
       it "should accept an FFI pointer" do
-        expect { subject.new FFI::Pointer.new(0) }.to raise_error(ArgumentError, /is not a valid Spotify link/)
+        expect { Hallon::Link.new(Spotify::Pointer.new(null_pointer, :link, false)) }.to raise_error(ArgumentError, /is not a valid spotify link/)
       end
 
-      it "should not initialize when given a Link" do
-        link = subject.new('spotify:user:burgestrand')
-        link.should_not_receive :to_str
-        subject.new link
+      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
     end
 
     describe "::valid?" do
       it "should be true for a valid link" do
-        subject.valid?("spotify:user:burgestrand").should be_true
+        Hallon::Link.valid?("spotify:user:burgestrand").should be_true
       end
 
       it "should be false for an invalid link" do
-        subject.valid?("omgwtfbbq").should be_false
+        Hallon::Link.valid?("omgwtfbbq").should be_false
       end
     end
   end
@@ -84,7 +82,7 @@ describe Hallon::Link do
     end
 
     it "should compare underlying pointers if #to_str is unavailable" do
-      object = Hallon::Link.new(FFI::Pointer.new(subject.pointer))
+      object = Hallon::Link.new(subject.pointer)
 
       def object.respond_to?(o)
         return false if o == :to_str

data/spec/hallon/linkable_spec.rb

@@ -10,40 +10,59 @@ describe Hallon::Linkable do
   let(:object) { klass.new }
   let(:pointer) { FFI::Pointer.new(1) }
 
-  before(:each) { Spotify.stub(:link_as_search) }
+  before(:each) { Spotify.stub(:link_as_search!) }
 
   it "should define the #from_link method" do
-    object.should_not respond_to :from_link
-    klass.from_link(:as_search)
-    object.should respond_to :from_link
+    object.respond_to?(:from_link, true).should be_false
+
+    klass.instance_eval do
+      from_link(:as_search)
+    end
+
+    object.respond_to?(:from_link, true).should be_true
   end
 
   describe "#from_link" do
     it "should call the appropriate Spotify function" do
-      Spotify.should_receive(:link_as_search).and_return(pointer)
+      Spotify.should_receive(:link_as_search!).and_return(pointer)
+
+      klass.instance_eval do
+        from_link(:as_search)
+      end
 
-      klass.from_link(:as_search)
-      object.from_link 'spotify:search:moo'
+      object.send(:from_link, 'spotify:search:moo')
     end
 
     it "should call the given block if necessary" do
-      Spotify.should_not_receive(:link_as_search)
+      Spotify.should_not_receive(:link_as_search!)
+
+      called  = false
+      pointer = double(:null? => false)
 
-      called = false
-      klass.from_link(:as_search) { called = true and pointer }
-      expect { object.from_link 'spotify:search:whatever' }.to change { called }
+      klass.instance_eval do
+        from_link(:as_search) do
+          called = true
+          pointer
+        end
+      end
+
+      expect { object.send(:from_link, 'spotify:search:whatever') }.to change { called }
     end
 
     it "should pass extra parameters to the defining block" do
       passed_args = nil
-      klass.from_link(:search) { |link, *args| passed_args = args and pointer }
-      object.from_link("spotify:search:burgestrand", :cool, 5)
-      passed_args.should eq [:cool, 5]
-    end
 
-    it "should fail, given a null pointer" do
-      klass.from_link(:as_search)
-      expect { object.from_link FFI::Pointer.new(0) }.to raise_error(Hallon::Error)
+      pointer = double(:null? => false)
+
+      klass.instance_eval do
+        from_link(:search) do |link, *args|
+          passed_args = args
+          pointer
+        end
+      end
+
+      object.send(:from_link, "spotify:search:burgestrand", :cool, 5)
+      passed_args.should eq [:cool, 5]
     end
   end
 end

data/spec/hallon/player_spec.rb

@@ -70,4 +70,12 @@ describe Hallon::Player do
       player.seek(1)
     end
   end
+
+  describe "#volume_normalization" do
+    it "should be settable and gettable" do
+      player.volume_normalization?.should be_false
+      player.volume_normalization = true
+      player.volume_normalization?.should be_true
+    end
+  end
 end