hallon 0.15.0 → 0.16.0

data/spec/hallon/track_spec.rb

@@ -1,70 +1,154 @@
 # coding: utf-8
 describe Hallon::Track do
-  it { should be_a Hallon::Loadable }
+  let(:track) do
+    Hallon::Track.new(mock_tracks[:default])
+  end
+
+  let(:empty_track) do
+    Hallon::Track.new(mock_tracks[:empty])
+  end
+
+  let(:autolinked_track) do
+    Hallon::Track.new(mock_tracks[:linked])
+  end
+
+  specify { track.should be_a Hallon::Loadable }
 
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:track:7N2Vc8u56VGA4KUrGbikC2#01:00" }
   end
 
-  let(:track) { Hallon::Track.new(mock_track) }
-  subject { track }
+  describe "#loaded?" do
+    it "returns true if the track is loaded" do
+      track.should be_loaded
+    end
+  end
 
-  it { should be_loaded }
-  its(:name)   { should eq "They" }
-  its(:disc)   { should be 2 }
-  its(:index)  { should be 7 }
-  its(:status) { should be :ok }
-  its(:duration)   { should eq 123.456 }
-  its(:popularity) { should eq 0.42 }
-  its(:album) { should eq Hallon::Album.new(mock_album) }
-  its(:artist) { should eq Hallon::Artist.new(mock_artist) }
-  its('artists.size') { should eq 2 }
-  its('artists.to_a') { should eq [mock_artist, mock_artist_two].map{ |p| Hallon::Artist.new(p) } }
+  describe "#name" do
+    it "returns the track’s name" do
+      track.name.should eq "They"
+    end
 
-  describe "#starred=" do
-    around { |test| mock_session(&test) }
+    it "returns an empty string if the track’s name is unavailable" do
+      empty_track.name.should be_empty
+    end
+  end
 
-    it "should delegate to session to unstar" do
-      session.should_receive(:unstar).with(track)
-      track.starred = false
+  describe "#disc" do
+    it "returns the track’s disc number in it’s album" do
+      track.disc.should eq 2
     end
+  end
 
-    it "should delegate to session to star" do
-      session.should_receive(:star).with(track)
-      track.starred = true
+  describe "#index" do
+    it "returns the track’s position on the disc" do
+      track.index.should eq 7
+    end
+  end
+
+  describe "#status" do
+    it "returns the track’s status" do
+      track.status.should eq :ok
     end
+  end
 
-    it "should change starred status of track" do
-      track.should be_starred
-      track.starred = false
-      track.should_not be_starred
+  describe "#duration" do
+    it "returns track’s duration" do
+      track.duration.should eq 123.456
+    end
+  end
+
+  describe "#popularity" do
+    it "returns the track’s popularity" do
+      track.popularity.should eq 42
     end
   end
 
-  describe "session bound queries" do
-    subject { Hallon::Track.new(mock_track) }
-    around  { |test| mock_session(&test) }
+  describe "#playable_track" do
+    it "returns the autolinked track" do
+      linked = autolinked_track.playable_track
+      linked.should_not eq autolinked_track
+      linked.should eq track
+    end
+
+    it "returns itself if the track is not autolinked" do
+      track.playable_track.should eq track
+    end
+  end
+
+  describe "#available?" do
+    it "returns true if the track is available for playback" do
+      track.should be_available
+    end
+  end
+
+  describe "#local?" do
+    it "returns true if the track is a local track" do
+      track.should_not be_local
+    end
+  end
 
-    it { should be_available }
-    it { should_not be_local }
-    it { should be_autolinked }
-    it { should be_starred }
+  describe "#autolinked?" do
+    it "returns true if the track is autolinked to another for playback" do
+      track.should be_autolinked
+    end
+  end
 
-    its(:availability) { should eq :available }
+  describe "#availability" do
+    it "returns the track’s availability" do
+      track.availability.should eq :available
+    end
   end
 
-  describe "album" do
-    it "should be an album when there is one" do
+  describe "#album" do
+    it "returns the track’s album" do
       track.album.should eq Hallon::Album.new(mock_album)
     end
 
-    it "should be nil when there isn’t one" do
-      Spotify.should_receive(:track_album).and_return(null_pointer)
-      track.album.should be_nil
+    it "returns nil if the track’s not loaded" do
+      empty_track.album.should be_nil
+    end
+  end
+
+  describe "#artist" do
+    it "returns the track’s artist" do
+      track.artist.should eq Hallon::Artist.new(mock_artist)
+    end
+
+    it "returns nil if the track’s not loaded" do
+      empty_track.artist.should be_nil
+    end
+  end
+
+  describe "#artists" do
+    it "returns an enumerator of the track’s artists" do
+      track.artists.to_a.should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two)
+    end
+
+    it "returns an empty enumerator if the track has no artists" do
+      empty_track.artists.should be_empty
+    end
+  end
+
+  describe "#starred=" do
+    it "should delegate to session to unstar" do
+      session.should_receive(:unstar).with(track)
+      track.starred = false
+    end
+
+    it "should delegate to session to star" do
+      session.should_receive(:star).with(track)
+      track.starred = true
+    end
+
+    it "should change starred status of track" do
+      track.should be_starred
+      track.starred = false
+      track.should_not be_starred
     end
   end
 
-  describe "to_link" do
+  describe "#to_link" do
     it "should pass the current offset by default" do
       track.should_receive(:offset).and_return(10)
       track.to_link.to_str.should match(/#00:10/)
@@ -91,9 +175,14 @@ describe Hallon::Track do
     let(:artist)   { Spotify.link_create_from_string!('spotify:artist:3bftcFwl4vqRNNORRsqm1G') }
     let(:album)    { Spotify.link_create_from_string!('spotify:album:1xvnWMz2PNFf7mXOSRuLws') }
 
+    it "does nothing if the track is not a placeholder" do
+      track.stub(:placeholder? => false)
+      track.unwrap.should eq track
+    end
+
     it "should unwrap a playlist placeholder into a playlist" do
       Spotify.should_receive(:link_create_from_track!).and_return(playlist)
-      mock_session { track.unwrap.should eq Hallon::Playlist.new(playlist) }
+      track.unwrap.should eq Hallon::Playlist.new(playlist)
     end
 
     it "should unwrap an album placeholder into an album" do
@@ -113,7 +202,7 @@ describe Hallon::Track do
     end
   end
 
-  describe "offset" do
+  describe "#offset" do
     let(:without_offset) { 'spotify:track:7N2Vc8u56VGA4KUrGbikC2' }
     let(:with_offset)    { without_offset + '#1:00' }
 
@@ -131,18 +220,38 @@ describe Hallon::Track do
   end
 
   describe "a local track" do
-    subject do
+    let(:local) do
       Hallon::Track.local "Nissy", "Emmy", "Coolio", 100
     end
 
-    its(:name) { should eq "Nissy" }
-    its("album.name") { should eq "Coolio" }
-    its("artist.name") { should eq "Emmy" }
-    its(:duration) { should eq 0.1 }
+    describe "#name" do
+      it "returns the track’s name" do
+        local.name.should eq "Nissy"
+      end
+    end
+
+    describe "#album" do
+      it "returns the track’s album" do
+        local.album.name.should eq "Coolio"
+      end
+    end
+
+    describe "#artist" do
+      it "returns the track’s artist" do
+        local.artist.name.should eq "Emmy"
+      end
+    end
+
+    describe "#duration" do
+      it "returns the track’s duration" do
+        local.duration.should eq 0.1
+      end
+    end
 
-    it do
-      Hallon::Session.should_receive(:instance).and_return(session)
-      should be_local
+    describe "#local?" do
+      it "returns true for local tracks" do
+        local.should be_local
+      end
     end
   end
 end

data/spec/hallon/user_post_spec.rb

@@ -1,7 +1,9 @@
 # coding: utf-8
 
 describe Hallon::User::Post do
-  it { described_class.should include Hallon::Loadable }
+  let(:post) do
+    Hallon::User::Post.create("burgestrand", "These be some tight tracks, yo!", tracks)
+  end
 
   let(:tracks) do
     [].tap do |tracks|
@@ -10,9 +12,7 @@ describe Hallon::User::Post do
     end
   end
 
-  let(:post) do
-    stub_session { Hallon::User::Post.create("burgestrand", "These be some tight tracks, yo!", tracks) }
-  end
+  specify { post.should be_a Hallon::Loadable }
 
   describe ".new" do
     it "should be private" do
@@ -27,7 +27,7 @@ describe Hallon::User::Post do
     end
 
     it "should allow you to post a single track" do
-      post = stub_session { Hallon::User::Post.create("burgestrand", nil, tracks[0]) }
+      post = Hallon::User::Post.create("burgestrand", nil, tracks[0])
       post.tracks.should eq tracks[0, 1]
     end
   end
@@ -59,6 +59,11 @@ describe Hallon::User::Post do
     it "should return the message sent with the post" do
       post.message.should eq "These be some tight tracks, yo!"
     end
+
+    it "returns an empty string if no message was sent" do
+      post = Hallon::User::Post.create("burgestrand", nil, tracks)
+      post.message.should be_nil
+    end
   end
 
   describe "#recipient" do

data/spec/hallon/user_spec.rb

@@ -1,80 +1,90 @@
 # coding: utf-8
 describe Hallon::User do
-  it { described_class.should include Hallon::Loadable }
+  let(:user) do
+    Hallon::User.new(mock_users[:default])
+  end
+
+  let(:empty_user) do
+    Hallon::User.new(mock_users[:empty])
+  end
+
+  specify { user.should be_a Hallon::Loadable }
 
   it_should_behave_like "a Linkable object" do
     let(:spotify_uri) { "spotify:user:burgestrand" }
     let(:custom_object) { "burgestrand" }
   end
 
-  describe "an instance" do
-    let(:user) { Hallon::User.new(mock_user) }
+  describe "#loaded?" do
+    it "should return true as the user is loaded" do
+      user.should be_loaded
+    end
+  end
+
+  describe "#name" do
+    it "should be the canonical name" do
+      user.name.should eq "burgestrand"
+    end
 
-    describe "#loaded?" do
-      it "should return true as the user is loaded" do
-        user.should be_loaded
-      end
+    it "returns an empty string if the name is not available" do
+      empty_user.name.should be_empty
     end
+  end
 
-    describe "#name" do
-      it "should be the canonical name" do
-        user.name.should eq "burgestrand"
-      end
+  describe "#display_name" do
+    it "should be the users’ display name" do
+      user.display_name.should eq "Burgestrand"
     end
 
-    describe "#display_name" do
-      it "should be the users’ display name" do
-        user.display_name.should eq "Burgestrand"
-      end
+    it "returns an empty string if the display name is not available" do
+      empty_user.name.should be_empty
     end
+  end
 
-    describe "#post" do
-      let(:post) { mock_session { user.post(tracks) } }
-      let(:tracks) { instantiate(Hallon::Track, mock_track, mock_track_two) }
+  describe "#post" do
+    let(:post) { user.post(tracks) }
+    let(:tracks) { instantiate(Hallon::Track, mock_track, mock_track_two) }
 
-      it "should post to the correct user" do
-        post.recipient_name.should eq user.name
-      end
+    it "should post to the correct user" do
+      post.recipient_name.should eq user.name
+    end
 
-      it "should post with the given message" do
-        post.message.should be_nil
-        stub_session { user.post("Hey ho!", tracks) }.message.should eq "Hey ho!"
-      end
+    it "should post with the given message" do
+      post.message.should be_nil
+      user.post("Hey ho!", tracks).message.should eq "Hey ho!"
+    end
 
-      it "should return nil on failure" do
-        stub_session { user.post([]).should be_nil }
-      end
+    it "should return nil on failure" do
+      user.post([]).should be_nil
     end
+  end
 
-    describe "#starred" do
-      let(:starred) { Hallon::Playlist.new("spotify:user:%s:starred" % user.name) }
+  describe "#starred" do
+    let(:starred) { Hallon::Playlist.new("spotify:user:%s:starred" % user.name) }
 
-      it "should return the users’ starred playlist" do
-        session.login 'Kim', 'pass'
-        session.should be_logged_in
-        mock_session { user.starred.should eq starred }
-      end
+    it "should return the users’ starred playlist" do
+      session.login 'Kim', 'pass'
+      session.should be_logged_in
+      user.starred.should eq starred
+    end
 
-      it "should return nil if not logged in" do
-        session.should_not be_logged_in
-        mock_session { user.starred.should be_nil }
-      end
+    it "should return nil if not available" do
+      empty_user.starred.should be_nil
     end
+  end
 
-    describe "#published" do
-      let(:published) { Hallon::PlaylistContainer.new(mock_container) }
+  describe "#published" do
+    let(:published) { Hallon::PlaylistContainer.new(mock_container) }
 
-      it "should return the playlist container of the user" do
-        Spotify.registry_add("spotify:container:%s" % user.name, mock_container)
+    it "should return the playlist container of the user" do
+      Spotify.registry_add("spotify:container:%s" % user.name, mock_container)
 
-        session.login('burgestrand', 'pass')
-        mock_session { user.published.should eq published }
-      end
+      session.login('burgestrand', 'pass')
+      user.published.should eq published
+    end
 
-      it "should return nil if not logged in" do
-        Spotify.should_receive(:session_publishedcontainer_for_user_create).and_return(null_pointer)
-        mock_session { user.published.should be_nil }
-      end
+    it "should return nil if not logged in" do
+      empty_user.published.should be_nil
     end
   end
 end

data/spec/spec_helper.rb

@@ -15,11 +15,22 @@ require 'hallon'
 # Bail on failure
 Thread.abort_on_exception = true
 
+# We don’t do long running tests.
+# Actually, some tests might deadlock, so we guard against
+# them doing that. It’s annoying.
+class SlowTestError < StandardError
+end
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
 
   config.before do
     Hallon::Session.stub(:instance?).and_return(true)
+    Hallon::Session.stub(:instance).and_return(session)
+  end
+
+  config.after do
+    Spotify.registry_clean
   end
 
   def fixture_image_path
@@ -35,21 +46,6 @@ RSpec.configure do |config|
     pointers.map { |x| klass.new(*x) }
   end
 
-  def mock_session(times = 1)
-    Hallon::Session.should_receive(:instance).at_least(times).times.and_return(session)
-    yield
-  end
-
-  def stub_session(target = nil)
-    if target
-      target.any_instance.stub(:session).and_return(session)
-    else
-      Hallon::Session.stub(:instance).and_return(session)
-    end
-
-    target || (yield if block_given?)
-  end
-
   def pointer_array_with(*args)
     ary = FFI::MemoryPointer.new(:pointer, args.size)
     ary.write_array_of_pointer args
@@ -76,3 +72,32 @@ end
 # Requires supporting files in ./support/ and ./fixtures/
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 Dir["#{File.dirname(__FILE__)}/fixtures/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.before do
+    Spotify.registry_add 'spotify:image:3ad93423add99766e02d563605c6e76ed2b0e400', mock_image
+    Spotify.registry_add 'spotify:user:burgestrand:playlist:megaplaylist', mock_playlist_two
+    Spotify.registry_add 'spotify:search:my+%C3%A5+utf8+%EF%A3%BF+query', mock_search
+    Spotify.registry_add 'spotify:search:', mock_empty_search
+
+    Spotify.registry_add 'spotify:albumbrowse:1xvnWMz2PNFf7mXOSRuLws', mock_albumbrowse
+    Spotify.registry_add 'spotify:album:1xvnWMz2PNFf7mXOSRuLws', mock_album
+
+    Spotify.registry_add 'spotify:albumbrowse:thisisanemptyalbumyoow', mock_empty_albumbrowse
+    Spotify.registry_add 'spotify:album:thisisanemptyalbumyoow', mock_empty_album
+
+    Spotify.registry_add 'spotify:artist:3bftcFwl4vqRNNORRsqm1G', mock_artist
+    Spotify.registry_add 'spotify:artistbrowse:3bftcFwl4vqRNNORRsqm1G', mock_artistbrowse
+
+    Spotify.registry_add 'spotify:artist:thisisanemptyartistyow', mock_empty_artist
+    Spotify.registry_add 'spotify:artistbrowse:thisisanemptyartistyow', mock_empty_artistbrowse
+
+    Spotify.registry_add 'spotify:container:burgestrand', mock_container
+
+    Spotify.registry_add 'spotify:track:7N2Vc8u56VGA4KUrGbikC2', mock_track
+
+    Spotify.registry_add 'spotify:user:burgestrand', mock_user
+    Spotify.registry_add 'spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi', mock_playlist
+    Spotify.registry_add 'spotify:user:burgestrand:starred', mock_playlist
+  end
+end