hallon 0.15.0 → 0.16.0

data/spec/hallon/album_spec.rb

@@ -1,59 +1,94 @@
 # coding: utf-8
 #
 describe Hallon::Album do
-  it { should be_a Hallon::Loadable }
+  let(:album) do
+    Hallon::Album.new(mock_albums[:default])
+  end
+
+  let(:empty_album) do
+    Hallon::Album.new(mock_albums[:empty])
+  end
+
+  specify { album.should be_a Hallon::Loadable }
 
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:album:1xvnWMz2PNFf7mXOSRuLws" }
   end
 
-  let(:album) { Hallon::Album.new(mock_album) }
-  subject { album }
+  describe ".types" do
+    subject { Hallon::Album.types }
 
-  its(:name) { should eq "Finally Woken" }
-  its(:release_year) { should be 2004 }
-  its(:type) { should be :single }
-  its(:browse) do
-    mock_session { should eq Hallon::AlbumBrowse.new(album) }
+    it { should be_an Array }
+    it { should include :single }
   end
 
-  it { should be_available }
-  it { should be_loaded }
+  describe "#name" do
+    it "returns the album’s name" do
+      album.name.should eq "Finally Woken"
+    end
 
-  describe "artist" do
-    it "should be nil if there is no artist" do
-      Spotify.should_receive(:album_artist).and_return(null_pointer)
-      album.artist.should be_nil
+    it "returns an empty string if the album is not loaded" do
+      empty_album.name.should be_empty
+    end
+  end
+
+  describe "#release_year" do
+    it "returns the album’s release year" do
+      album.release_year.should eq 2004
+    end
+  end
+
+  describe "#type" do
+    it "returns the album’s type" do
+      album.type.should eq :single
+    end
+  end
+
+  describe "#browse" do
+    it "returns the album’s browser object" do
+      album.browse.should eq Hallon::AlbumBrowse.new(album)
     end
+  end
 
+  describe "#available?" do
+    it "returns true when the album is available" do
+      album.should be_available
+    end
+  end
+
+  describe "#loaded?" do
+    it "returns true when the album is loaded" do
+      album.should be_loaded
+    end
+  end
+
+  describe "artist" do
     it "should be an artist if it exists" do
       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)
-      album.cover.should be_nil
+    it "should be nil if there is no artist" do
+      empty_album.artist.should be_nil
     end
+  end
 
+  describe "#cover" do
     it "should be an image if it exists" do
-      stub_session { album.cover.should eq Hallon::Image.new(mock_image_id) }
+      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
+      empty_album.cover.should be_nil
     end
+  end
 
+  describe "#cover_link" do
     it "should be a link if it exists" do
       album.cover_link.should eq Hallon::Link.new("spotify:image:3ad93423add99766e02d563605c6e76ed2b0e400")
     end
-  end
 
-  describe ".types" do
-    specify { Hallon::Album.types.should_not be_empty }
+    it "should be nil if there is no image" do
+      empty_album.cover_link.should be_nil
+    end
   end
 end

data/spec/hallon/artist_browse_spec.rb

@@ -1,11 +1,22 @@
 # coding: utf-8
+
 describe Hallon::ArtistBrowse do
-  it { should be_a Hallon::Loadable }
+  let(:browse) do
+    artist = Hallon::Artist.new(mock_artists[:default])
+    Hallon::ArtistBrowse.new(artist)
+  end
+
+  let(:empty_browse) do
+    artist = Hallon::Artist.new(mock_artists[:empty])
+    Hallon::ArtistBrowse.new(artist)
+  end
+
+  specify { browse.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)
-      expect { mock_session { Hallon::ArtistBrowse.new(mock_artist) } }.to raise_error(FFI::NullPointerError)
+      expect { Hallon::ArtistBrowse.new(mock_artist) }.to raise_error(FFI::NullPointerError)
     end
 
     it "should raise an error given a non-album spotify pointer" do
@@ -13,48 +24,112 @@ describe Hallon::ArtistBrowse do
     end
   end
 
-  let(:browse) do
-    artist = Hallon::Artist.new(mock_artist)
-    mock_session { Hallon::ArtistBrowse.new(artist) }
+  describe '.types' do
+    subject { Hallon::ArtistBrowse.types }
+
+    it { should be_an Array }
+    it { should include :full }
+  end
+
+  describe "#loaded?" do
+    it "is true when the artist browser is loaded" do
+      browse.should be_loaded
+    end
   end
 
-  subject { browse }
+  describe "#status" do
+    it "returns the artist browser’s status" do
+      browse.status.should eq :ok
+    end
+  end
 
-  it { should be_loaded }
-  its(:status) { should eq :ok }
-  its(:artist) { should eq Hallon::Artist.new(mock_artist) }
+  describe "#biography" do
+    it "returns the artist’s biography" do
+      browse.biography.should eq 'grew up in DA BLOCK'
+    end
 
-  its('portraits.size') { should eq 2 }
-  its('portraits.to_a') do
-    stub_session { should eq instantiate(Hallon::Image, mock_image_id, mock_image_id) }
+    it "returns an empty string when the artist browser is not loaded" do
+      empty_browse.biography.should be_empty
+    end
   end
 
-  its('portrait_links.size') { should eq 2 }
-  its('portrait_links.to_a') { should eq instantiate(Hallon::Link, mock_image_link, mock_image_link) }
+  describe "#artist" do
+    it "returns the artist" do
+      browse.artist.should eq Hallon::Artist.new(mock_artists[:default])
+    end
 
-  its('tracks.size') { should eq 2 }
-  its('tracks.to_a') { should eq [mock_track, mock_track_two].map{ |p| Hallon::Track.new(p) } }
-  its('albums.size') { should eq 1 }
-  its('albums.to_a') { should eq [Hallon::Album.new(mock_album)] }
-  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' }
+    it "returns nil if the artist browser is not loaded" do
+      empty_browse.artist.should be_nil
+    end
+  end
 
-  describe "#request_duration" do
-    it "should return the request duration in seconds" do
-      browse.request_duration.should eq 2.751
+  describe "#portraits" do
+    it "returns an enumerator of the artist’s portraits" do
+      browse.portraits.to_a.should eq instantiate(Hallon::Image, mock_image_id, mock_image_id)
     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
+    it "returns an empty enumerator when the artist browser is not loaded" do
+      empty_browse.portraits.size.should eq 0
     end
   end
 
-  describe '.types' do
-    subject { Hallon::ArtistBrowse.types }
+  describe "#portrait_links" do
+    it "returns an enumerator of the artist’s portrait links" do
+      browse.portrait_links.to_a.should eq instantiate(Hallon::Link, mock_image_link, mock_image_link)
+    end
 
-    it { should be_an Array }
-    it { should include :full }
+    it "returns an empty enumerator when the artist browser is not loaded" do
+      empty_browse.portrait_links.size.should eq 0
+    end
+  end
+
+  describe "#tracks" do
+    it "returns an enumerator of the artist’s tracks" do
+      browse.tracks.to_a.should eq instantiate(Hallon::Track, mock_track, mock_track_two)
+    end
+
+    it "returns an empty enumerator when the artist browser is not loaded" do
+      empty_browse.tracks.size.should eq 0
+    end
+  end
+
+  describe "#albums" do
+    it "returns an enumerator of the artist’s albums" do
+      browse.albums.to_a.should eq instantiate(Hallon::Album, mock_album)
+    end
+
+    it "returns an empty enumerator when the artist browser is not loaded" do
+      empty_browse.albums.size.should eq 0
+    end
+  end
+
+  describe "#similar_artists" do
+    it "returns an enumerator of the artist’s albums" do
+      browse.similar_artists.to_a.should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two)
+    end
+
+    it "returns an empty enumerator when the artist browser is not loaded" do
+      empty_browse.similar_artists.size.should eq 0
+    end
+  end
+
+  describe "#top_hits" do
+    it "returns an enumerator of the artist’s top hits" do
+      browse.top_hits.to_a.should eq instantiate(Hallon::Track, mock_track)
+    end
+
+    it "returns an empty enumerator when the artist browser is not loaded" do
+      empty_browse.top_hits.should be_empty
+    end
+  end
+
+  describe "#request_duration" do
+    it "should return the request duration in seconds" do
+      browse.request_duration.should eq 2.751
+    end
+
+    it "should be zero if the request was fetched from local cache" do
+      empty_browse.request_duration.should eq 0
+    end
   end
 end

data/spec/hallon/artist_spec.rb

@@ -1,20 +1,38 @@
 # coding: utf-8
 describe Hallon::Artist do
-  it { should be_a Hallon::Loadable }
+  let(:artist) do
+    Hallon::Artist.new(mock_artists[:default])
+  end
+
+  let(:empty_artist) do
+    Hallon::Artist.new(mock_artists[:empty])
+  end
+
+  specify { artist.should be_a Hallon::Loadable }
 
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:artist:3bftcFwl4vqRNNORRsqm1G" }
   end
 
-  let(:artist) { Hallon::Artist.new(mock_artist) }
-  subject { artist }
+  describe "#loaded?" do
+    it "returns true when the artist is loaded" do
+      artist.should be_loaded
+    end
+  end
 
-  it { should be_loaded }
-  its(:name) { should eq "Jem" }
+  describe "#name" do
+    it "returns the artist’s name" do
+      artist.name.should eq "Jem"
+    end
+
+    it "returns an empty string if the artist is not loaded" do
+      empty_artist.name.should be_empty
+    end
+  end
 
   describe "#browse" do
     it "should return an artist browsing object" do
-      mock_session(2) { subject.browse.should eq Hallon::ArtistBrowse.new(mock_artist) }
+      artist.browse.should eq Hallon::ArtistBrowse.new(mock_artist)
     end
 
     it "should default to full browsing" do
@@ -29,26 +47,22 @@ describe Hallon::Artist do
   end
 
   describe "#portrait" do
-    let(:link) { Hallon::Link.new(mock_image_uri) }
-
-    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
-
     it "should be an image if it exists" do
-      stub_session { artist.portrait.should eq Hallon::Image.new(mock_image_id) }
+      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(:link_create_from_artist_portrait).and_return(null_pointer)
-      artist.portrait_link.should be_nil
+      empty_artist.portrait.should be_nil
     end
+  end
 
+  describe "#portrait_link" do
     it "should be a link if it exists" do
       artist.portrait_link.should eq Hallon::Link.new(mock_image_uri)
     end
+
+    it "should be nil if an image is not available" do
+      empty_artist.portrait_link.should be_nil
+    end
   end
 end

data/spec/hallon/blob_spec.rb

@@ -0,0 +1,6 @@
+describe Hallon::Blob do
+  it "is infectious" do
+    Hallon::Blob("string").should be_a Hallon::Blob
+    Hallon::Blob("string").should be_a String
+  end
+end

data/spec/hallon/enumerator_spec.rb

@@ -50,6 +50,16 @@ describe Hallon::Enumerator do
     end
   end
 
+  describe "#empty?" do
+    it "returns true if the enumerator is empty" do
+      enumerator(0).should be_empty
+    end
+
+    it "returns false if the enumerator is not empty" do
+      enum.should_not be_empty
+    end
+  end
+
   describe "#[]" do
     it "should return nil if #[x] is not within the enumerators’ size (no matter if the value exists or not)" do
       enum.should_receive(:size).and_return(1)

data/spec/hallon/error_spec.rb

@@ -3,7 +3,7 @@ describe Hallon::Error do
 
   it { should <= RuntimeError }
 
-  describe "::disambiguate" do
+  describe ".disambiguate" do
     it "should not fail on invalid numbers" do
       subject.disambiguate(10000).should eq [-1, nil]
     end
@@ -13,7 +13,7 @@ describe Hallon::Error do
     end
   end
 
-  describe "::explain" do
+  describe ".explain" do
     it "should work properly given an integer" do
       subject.explain(0).should eq 'sp_error: 0'
     end
@@ -23,7 +23,7 @@ describe Hallon::Error do
     end
   end
 
-  describe "::maybe_raise" do
+  describe ".maybe_raise" do
     it "should not raise error when given 0 as error code" do
       expect { subject.maybe_raise(0) }.to_not raise_error
     end
@@ -47,7 +47,7 @@ describe Hallon::Error do
     end
   end
 
-  describe "::table" do
+  describe ".table" do
     it "should return a hash of symbol to integer" do
       Hallon::Error.table[:ok].should eq 0
     end

data/spec/hallon/hallon_spec.rb

@@ -18,7 +18,7 @@ describe Hallon do
     end
   end
 
-  describe "#load_timeout" do
+  describe ".load_timeout" do
     it "should raise an error given a negative timeout" do
       expect { Hallon.load_timeout = -1 }.to raise_error(ArgumentError)
     end

data/spec/hallon/image_spec.rb

@@ -2,76 +2,87 @@
 require 'ostruct'
 
 describe Hallon::Image do
-  it { described_class.should include Hallon::Loadable }
+  let(:image) do
+    Hallon::Image.new(mock_image)
+  end
+
+  let(:empty_image) do
+    Hallon::Image.new(mock_empty_image)
+  end
 
   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) { Hallon::Image }
+  end
 
-    let(:described_class) do
-      real_session = session
-      Hallon::Image.dup.tap do |klass|
-        klass.class_eval do
-          define_method(:session) { real_session }
-        end
-      end
+  specify { image.should be_a Hallon::Loadable }
+
+  describe "#loaded?" do
+    it "returns true when the image is loaded" do
+      image.should be_loaded
     end
   end
 
-  describe "an image instance" do
-    subject { image }
-    let(:image) { Hallon::Image.new(mock_image) }
+  describe "#status" do
+    it "returns the image’s status" do
+      image.status.should eq :ok
+    end
+  end
 
-    it { should be_loaded }
-    its(:status) { should be :ok }
-    its(:format) { should be :jpeg }
+  describe "#format" do
+    it "returns the image’s format" do
+      image.format.should eq :jpeg
+    end
+  end
 
-    describe "#id" do
-      it "should return the image id as a hexadecimal string" do
-        image.id.should eq mock_image_hex
-      end
+  describe "#id" do
+    it "returns 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
+  describe "#raw_id" do
+    it "returns the image id as a binary string" do
+      image.raw_id.should eq mock_image_id
     end
+  end
 
-    describe "#data" do
-      subject { image.data }
+  describe "#data" do
+    it "returns the image’s data" do
+      image.data.should eq File.open(fixture_image_path, 'r:binary', &:read)
+    end
 
-      it "should correspond to the fixture image" do
-        should eq File.open(fixture_image_path, 'r:binary', &:read)
-      end
+    it "has a binary encoding" do
+      image.data.encoding.name.should eq 'ASCII-8BIT'
+    end
 
-      it "should have a binary encoding" do
-        subject.encoding.name.should eq 'ASCII-8BIT'
-      end
+    it "returns an empty string if the image is not loaded" do
+      empty_image.data.should be_empty
     end
+  end
 
-    describe "#to_link" do
-      it "should retrieve the Spotify URI" do
-        image.to_link.should eq Hallon::Link.new("spotify:image:#{image.id}")
-      end
+  describe "#to_link" do
+    it "should retrieve the Spotify URI" do
+      image.to_link.should eq Hallon::Link.new("spotify:image:#{image.id}")
     end
+  end
 
-    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(:raw_id).and_return(image.raw_id)
+  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(:raw_id).and_return(image.raw_id)
 
-        image.should eq other
-        image.should_not eq double
-      end
+      image.should eq other
+      image.should_not eq double
+    end
 
-      it "should not call #id if other is not an image" do
-        other = double
-        other.should_not_receive(:raw_id)
+    it "should not call #id if other is not an image" do
+      other = double
+      other.should_not_receive(:raw_id)
 
-        image.should_not eq other
-      end
+      image.should_not eq other
     end
   end
 end