hallon 0.13.0 → 0.14.0

data/lib/hallon/version.rb

@@ -3,5 +3,5 @@ module Hallon
   # Current release version of Hallon
   #
   # @see http://semver.org/
-  VERSION = [0, 13, 0].join('.')
+  VERSION = [0, 14, 0].join('.')
 end

data/spec/hallon/album_browse_spec.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 describe Hallon::AlbumBrowse do
+  it { should be_a Hallon::Loadable }
+
   describe ".new" do
     it "should raise an error if the browse request failed" do
       Spotify.should_receive(:albumbrowse_create).and_return(null_pointer)

data/spec/hallon/album_spec.rb

@@ -1,5 +1,8 @@
 # coding: utf-8
+#
 describe Hallon::Album do
+  it { should be_a Hallon::Loadable }
+
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:album:1xvnWMz2PNFf7mXOSRuLws" }
   end
@@ -28,21 +31,25 @@ describe Hallon::Album do
     end
   end
 
-  describe "cover" do
+  describe "#cover" do
     it "should be nil if there is no image" do
       Spotify.should_receive(:album_cover).and_return(null_pointer)
       album.cover.should be_nil
-
-      Spotify.should_receive(:link_create_from_album_cover).and_return(null_pointer)
-      album.cover(false).should be_nil
     end
 
     it "should be an image if it exists" do
-      mock_session { album.cover.id.should eq mock_image_hex }
+      stub_session { album.cover.should eq Hallon::Image.new(mock_image_id) }
+    end
+  end
+
+  describe "#cover_link" do
+    it "should be nil if there is no image" do
+      Spotify.should_receive(:link_create_from_album_cover).and_return(null_pointer)
+      album.cover_link.should be_nil
     end
 
-    it "should be a link if requested" do
-      album.cover(false).to_str.should eq "spotify:image:3ad93423add99766e02d563605c6e76ed2b0e450"
+    it "should be a link if it exists" do
+      album.cover_link.should eq Hallon::Link.new("spotify:image:3ad93423add99766e02d563605c6e76ed2b0e450")
     end
   end
 

data/spec/hallon/artist_browse_spec.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 describe Hallon::ArtistBrowse do
+  it { should be_a Hallon::Loadable }
+
   describe ".new" do
     it "should raise an error if the browse request failed" do
       Spotify.should_receive(:artistbrowse_create).and_return(null_pointer)

data/spec/hallon/artist_spec.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 describe Hallon::Artist do
+  it { should be_a Hallon::Loadable }
+
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:artist:3bftcFwl4vqRNNORRsqm1G" }
   end
@@ -29,20 +31,24 @@ describe Hallon::Artist do
   describe "#portrait" do
     let(:link) { Hallon::Link.new(mock_image_uri) }
 
-    specify "as an image" do
-      mock_session(2) { artist.portrait.should eq Hallon::Image.new(mock_image_id) }
+    it "should be nil if an image is not available" do
+      Spotify.should_receive(:artist_portrait).and_return(null_pointer)
+      artist.portrait.should be_nil
     end
 
-    specify "as a link" do
-      artist.portrait(false).should eq Hallon::Link.new(mock_image_uri)
+    it "should be an image if it exists" do
+      stub_session { artist.portrait.should eq Hallon::Image.new(mock_image_id) }
     end
+  end
 
+  describe "#portrait_link" do
     it "should be nil if an image is not available" do
-      Spotify.should_receive(:artist_portrait).and_return(null_pointer)
-      artist.portrait.should be_nil
-
       Spotify.should_receive(:link_create_from_artist_portrait).and_return(null_pointer)
-      artist.portrait(false).should be_nil
+      artist.portrait_link.should be_nil
+    end
+
+    it "should be a link if it exists" do
+      artist.portrait_link.should eq Hallon::Link.new(mock_image_uri)
     end
   end
 end

data/spec/hallon/hallon_spec.rb

@@ -18,4 +18,16 @@ describe Hallon do
       it { should match uri }
     end
   end
+
+  describe "#load_timeout" do
+    it "should raise an error given a negative timeout" do
+      expect { Hallon.load_timeout = -1 }.to raise_error(ArgumentError)
+    end
+
+    it "should allow setting and retrieving the value" do
+      Hallon.load_timeout.should eq 5
+      Hallon.load_timeout = 0.2
+      Hallon.load_timeout.should eq 0.2
+    end
+  end
 end

data/spec/hallon/image_spec.rb

@@ -2,6 +2,8 @@
 require 'ostruct'
 
 describe Hallon::Image do
+  it { described_class.should include Hallon::Loadable }
+
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:image:#{mock_image_hex}" }
     let(:custom_object) { mock_image_hex }
@@ -24,9 +26,16 @@ describe Hallon::Image do
     its(:status) { should be :ok }
     its(:format) { should be :jpeg }
 
-    describe "id" do
-      specify("in hex") { subject.id.should eq mock_image_hex }
-      specify("raw") { subject.id(true).should eq mock_image_id }
+    describe "#id" do
+      it "should return the image id as a hexadecimal string" do
+        image.id.should eq mock_image_hex
+      end
+    end
+
+    describe "#raw_id" do
+      it "should return the image id as a binary string" do
+        image.raw_id.should eq mock_image_id
+      end
     end
 
     describe "#data" do
@@ -51,17 +60,17 @@ describe Hallon::Image 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))
+        other.should_receive(:raw_id).and_return(image.raw_id)
 
-        image.should === other
-        image.should_not === double
+        image.should eq other
+        image.should_not eq double
       end
 
       it "should not call #id if other is not an image" do
-        o = Object.new
-        o.should_not_receive(:id)
+        other = double
+        other.should_not_receive(:raw_id)
 
-        image.should_not eq o
+        image.should_not eq other
       end
     end
   end

data/spec/hallon/loadable_spec.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+describe Hallon::Loadable do
+  let(:session) { double(:session, :process_events => 5) }
+  let(:loadable) do
+    _session = session
+    Class.new do
+      include Hallon::Loadable
+
+      define_method(:session) { _session }
+    end.new
+  end
+
+  describe "#load" do
+    it "should timeout if the object does not load in time" do
+      Hallon.stub(:load_timeout).and_return(0.001)
+      loadable.stub(:loaded?).and_return(false)
+      expect { loadable.load }.to raise_error(Hallon::TimeoutError)
+    end
+
+    it "should use the Hallon.load_timeout by default" do
+      Hallon.should_receive(:load_timeout).and_return(0.075)
+      Timeout.should_receive(:timeout).with(0.075, Hallon::TimeoutError).and_yield
+      loadable.stub(:loaded?).and_return(true)
+      loadable.load
+    end
+
+    it "should return the object in question on success" do
+      loadable.stub(:loaded?).and_return(true)
+      loadable.load.should eq loadable
+    end
+
+    it "should raise an error when status is an error" do
+      session.should_receive(:process_events).once
+      loadable.stub(:loaded?).and_return(false)
+      loadable.stub(:status).and_return(:other_permanent)
+      expect { loadable.load }.to raise_error(Hallon::Error)
+    end
+
+    it "should not raise an error when status is_loading" do
+      loadable.stub(:loaded?).and_return(false, true)
+      loadable.stub(:status).and_return(:is_loading)
+      loadable.load.should eq loadable
+    end
+  end
+end

data/spec/hallon/observable/playlist_spec.rb

@@ -1,7 +1,13 @@
 describe Hallon::Observable::Playlist do
   let(:trackpointers_size) { 2 }
+  let(:track_index_pointers) do
+    tracks = FFI::MemoryPointer.new(:pointer, trackpointers_size)
+    tracks.write_array_of_int([0, 1])
+    tracks
+  end
+
   let(:trackpointers) do
-    tracks = FFI::MemoryPointer.new(:pointer, 2)
+    tracks = FFI::MemoryPointer.new(:pointer, trackpointers_size)
     tracks.write_array_of_pointer([mock_track, mock_track_two])
     tracks
   end
@@ -16,13 +22,13 @@ describe Hallon::Observable::Playlist do
   end
 
   specification_for_callback "tracks_removed" do
-    let(:input)  { [a_pointer, trackpointers, trackpointers_size, :userdata] }
-    let(:output) { [tracks, subject] }
+    let(:input)  { [a_pointer, track_index_pointers, trackpointers_size, :userdata] }
+    let(:output) { [[0, 1], subject] }
   end
 
   specification_for_callback "tracks_moved" do
-    let(:input)  { [a_pointer, trackpointers, trackpointers_size, 7, :userdata] }
-    let(:output) { [tracks, 7, subject] }
+    let(:input)  { [a_pointer, track_index_pointers, trackpointers_size, 7, :userdata] }
+    let(:output) { [[0, 1], 7, subject] }
   end
 
   specification_for_callback "playlist_renamed" do

data/spec/hallon/observable_spec.rb

@@ -136,6 +136,12 @@ describe Hallon::Observable do
       expect { subject.send(:subscribe_for_callbacks) {} }.to raise_error(ArgumentError)
     end
 
+    it "should do nothing if the result is a null pointer" do
+      klass.should_not_receive(:subscribe)
+      klass.any_instance.stub(:pointer).and_return(FFI::Pointer::NULL)
+      subject.send(:subscribe_for_callbacks) {}
+    end
+
     it "should always yield the *same* object" do
       a = klass.new
       b = klass.new

data/spec/hallon/playlist_container_spec.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 describe Hallon::PlaylistContainer do
+  it { should be_a Hallon::Loadable }
+
   let(:container) { Hallon::PlaylistContainer.new(mock_container) }
 
   subject { container }
@@ -18,6 +20,10 @@ describe Hallon::PlaylistContainer do
           container.contents[-1].should eq playlist
         end.to change{ container.size }.by(1)
       end
+
+      it "should raise an error if the name is invalid" do
+        expect { container.add(" ") }.to raise_error(ArgumentError)
+      end
     end
 
     context "given a string that’s a valid spotify playlist uri" do

data/spec/hallon/playlist_spec.rb

@@ -2,9 +2,11 @@
 require 'time'
 
 describe Hallon::Playlist do
+  it { should be_a Hallon::Loadable }
+
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi" }
-    let(:described_class) { Hallon::Playlist.tap { |o| stub_session(o.any_instance) } }
+    let(:described_class) { stub_session(Hallon::Playlist) }
   end
 
   subject { playlist }
@@ -12,6 +14,20 @@ describe Hallon::Playlist do
     Hallon::Playlist.new(mock_playlist)
   end
 
+  describe ".invalid_name?" do
+    it "should return false if the name is valid" do
+      Hallon::Playlist.invalid_name?("Moo").should be_false
+    end
+
+    it "should return an error message when the name is blank" do
+      Hallon::Playlist.invalid_name?(" ").should match "blank"
+    end
+
+    it "should return an error message when the name is too long" do
+      Hallon::Playlist.invalid_name?("Moo" * 256).should match "bytes"
+    end
+  end
+
   it { should be_loaded }
   it { should be_collaborative }
   it { should_not be_pending }
@@ -108,8 +124,9 @@ describe Hallon::Playlist do
       playlist.tracks.to_a.should eq new_tracks
     end
 
-    it "should raise an error if the operation cannot be completed" do
-      expect { playlist.remove(-1) }.to raise_error(Hallon::Error)
+    it "should raise an error if given invalid parameters" do
+      expect { playlist.remove(-1) }.to raise_error(ArgumentError)
+      expect { playlist.remove(playlist.size) }.to raise_error(ArgumentError)
     end
   end
 
@@ -135,7 +152,7 @@ describe Hallon::Playlist do
     end
 
     it "should fail given an empty name" do
-      expect { playlist.name = "" }.to raise_error(Hallon::Error)
+      expect { playlist.name = "" }.to raise_error(ArgumentError)
     end
 
     it "should fail given a name of only spaces" do

data/spec/hallon/search_spec.rb

@@ -1,4 +1,6 @@
 describe Hallon::Search do
+  it { should be_a Hallon::Loadable }
+
   subject { search }
   let(:search) do
     Spotify.registry_add 'spotify:search:my query', mock_search

data/spec/hallon/toplist_spec.rb

@@ -1,23 +1,56 @@
 describe Hallon::Toplist do
+  it { should be_a Hallon::Loadable }
+
   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 }
+
+  describe ".new" do
+    it "should fail given an invalid type" do
+      expect { stub_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.registry_add 'spotify:toplist:user:Kim:tracks', mock_toplistbrowse
+      stub_session { Hallon::Toplist.new(:tracks, "Kim").should be_loaded }
+    end
+
+    it "should pass the correct region to libspotify" do
+      Spotify.registry_add 'spotify:toplist:tracks:SE', mock_toplistbrowse
+      mock_session { Hallon::Toplist.new(:tracks, :se).should be_loaded }
+    end
+  end
+
   it { should be_loaded }
   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) }
+  describe "#type" do
+    it "should be the same as the type given to .new" do
+      toplist = mock_session { Hallon::Toplist.new(:tracks, :se) }
+      toplist.type.should eq :tracks
+    end
+  end
+
+  describe "#results" do
+    it "should return an enumerator of the correct type" do
+      toplist.should_receive(:type).and_return(:artists)
+      toplist.results.to_a.should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two)
+    end
 
-  its('albums.size') { should eq 1 }
-  its('albums.to_a') { should eq instantiate(Hallon::Album, mock_album) }
+    it "should return an enumerator of the correct type" do
+      toplist.should_receive(:type).and_return(:albums)
+      toplist.results.to_a.should eq instantiate(Hallon::Album, mock_album)
+    end
 
-  its('tracks.size') { should eq 2 }
-  its('tracks.to_a') { should eq instantiate(Hallon::Track, mock_track, mock_track_two) }
+    it "should return an enumerator of the correct type" do
+      toplist.should_receive(:type).and_return(:tracks)
+      toplist.results.to_a.should eq instantiate(Hallon::Track, mock_track, mock_track_two)
+    end
+  end
 
   describe "#request_duration" do
     it "should return the request duration in seconds" do
@@ -29,20 +62,4 @@ describe Hallon::Toplist do
       toplist.request_duration.should be_nil
     end
   end
-
-  describe ".new" do
-    it "should fail given an invalid type" do
-      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.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
-      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,5 +1,7 @@
 # coding: utf-8
 describe Hallon::Track do
+  it { should be_a Hallon::Loadable }
+
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:track:7N2Vc8u56VGA4KUrGbikC2#01:00" }
   end