hallon 0.15.0 → 0.16.0

data/spec/hallon/player_spec.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
 describe Hallon::Player do
-  let(:player) { Hallon::Player.new(session, AudioDriverMock) }
+  let(:player) { Hallon::Player.new(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?

data/spec/hallon/playlist_container_spec.rb

@@ -1,14 +1,48 @@
 # coding: utf-8
 describe Hallon::PlaylistContainer do
-  it { should be_a Hallon::Loadable }
+  let(:container) do
+    Hallon::PlaylistContainer.new(mock_containers[:default])
+  end
+
+  let(:empty_container) do
+    Hallon::PlaylistContainer.new(mock_containers[:empty])
+  end
+
+  let(:empty_playlist) do
+    Hallon::Playlist.new(mock_playlists[:empty])
+  end
+
+  let(:playlist) do
+    Hallon::Playlist.new(mock_playlists[:default])
+  end
 
-  let(:container) { Hallon::PlaylistContainer.new(mock_container) }
+  specify { container.should be_a Hallon::Loadable }
 
-  subject { container }
+  describe "#loaded?" do
+    it "returns true if the playlist container is loaded" do
+      container.should be_loaded
+    end
+  end
 
-  it { should be_loaded }
-  its(:owner) { should eq Hallon::User.new("burgestrand") }
-  its(:size) { should eq 4 }
+  describe "#owner" do
+    it "returns the playlist container’s owner" do
+      container.owner.should eq Hallon::User.new("burgestrand") 
+    end
+
+    it "returns nil if the playlist container is not loaded" do
+      empty_container.owner.should be_nil
+    end
+  end
+
+  describe "#size" do
+    it "returns the number of playlists inside the container" do
+      container.size.should eq 4
+    end
+
+    it "returns zero if the container is empty" do
+      empty_container.size.should eq 0
+    end
+  end
 
   describe "#add" do
     context "given a string that’s not a valid spotify playlist uri" do
@@ -29,7 +63,7 @@ describe Hallon::PlaylistContainer do
     context "given a string that’s a valid spotify playlist uri" do
       it "should add the existing Playlist at the end of the container" do
         playlist_uri = "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi"
-        playlist = mock_session { Hallon::Playlist.new(playlist_uri) }
+        playlist = Hallon::Playlist.new(playlist_uri)
 
         expect do
           new_playlist = container.add(playlist_uri)
@@ -169,13 +203,31 @@ describe Hallon::PlaylistContainer do
   end
 
   describe Hallon::PlaylistContainer::Folder do
-    subject { container.contents[1] }
-    let(:folder) { subject }
+    let(:folder) { container.contents[1] }
+
+    describe "#id" do
+      it "returns the folder’s ID" do
+        folder.id.should eq 1337
+      end
+    end
+
+    describe "#name" do
+      it "returns the folder’s name" do
+        folder.name.should eq "Boogie"
+      end
+    end
+
+    describe "#begin" do
+      it "returns the folder’s starting index" do
+        folder.begin.should eq 1
+      end
+    end
 
-    its(:id)    { should be 1337 }
-    its(:name)  { should eq "Boogie" }
-    its(:begin) { should be 1 }
-    its(:end)   { should be 3 }
+    describe "#end" do
+      it "returns the folder’s ending index" do
+        folder.end.should eq 3
+      end
+    end
 
     describe "#moved?" do
       it "should return true if the folder has moved" do
@@ -222,4 +274,35 @@ describe Hallon::PlaylistContainer do
       end
     end
   end
+
+  describe "#unseen_tracks_count_for" do
+    it "returns the number of unseen tracks for the given playlist" do
+      container.unseen_tracks_count_for(playlist).should eq 4
+    end
+
+    it "raises an error if the result was an error" do
+      expect { container.unseen_tracks_count_for(empty_playlist) }.to raise_error(Hallon::OperationFailedError)
+    end
+  end
+
+  describe "#unseen_tracks_for" do
+    it "returns an array of unseen tracks" do
+      container.unseen_tracks_for(playlist).should eq playlist.tracks.to_a
+    end
+
+    it "returns an array of unseen tracks, no bigger than the given count" do
+      container.unseen_tracks_for(playlist, 2).should eq playlist.tracks.to_a[0, 2]
+    end
+
+    it "raises an error if the result was an error (but count was not)" do
+      Spotify.should_receive(:playlistcontainer_get_unseen_tracks).and_return(4, -1)
+      expect { container.unseen_tracks_for(empty_playlist) }.to raise_error(Hallon::OperationFailedError)
+    end
+  end
+
+  describe "#clear_unseen_tracks_for" do
+    it "raises an error if the operation failed" do
+      expect { container.clear_unseen_tracks_for(empty_playlist) }.to raise_error(Hallon::OperationFailedError)
+    end
+  end
 end

data/spec/hallon/playlist_spec.rb

@@ -2,16 +2,19 @@
 require 'time'
 
 describe Hallon::Playlist do
-  it { should be_a Hallon::Loadable }
+  let(:playlist) do
+    Hallon::Playlist.new(mock_playlists[:default])
+  end
 
-  it_should_behave_like "a Linkable object" do
-    let(:spotify_uri) { "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi" }
-    let(:described_class) { stub_session(Hallon::Playlist) }
+  let(:empty_playlist) do
+    Hallon::Playlist.new(mock_playlists[:empty])
   end
 
-  subject { playlist }
-  let(:playlist) do
-    Hallon::Playlist.new(mock_playlist)
+  specify { playlist.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 }
   end
 
   describe ".invalid_name?" do
@@ -28,31 +31,164 @@ describe Hallon::Playlist do
     end
   end
 
-  it { should be_loaded }
-  it { should be_collaborative }
-  it { should_not be_pending }
-  it { stub_session { should be_in_ram } }
-  it { stub_session { should_not be_available_offline } }
+  describe "#loaded?" do
+    it "is true when the playlist is loaded" do
+      playlist.should be_loaded
+    end
+
+    it "is false when the playlist is not loaded" do
+      empty_playlist.should_not be_loaded
+    end
+  end
+
+  describe "#name" do
+    it "returns the playlist’s name as a string" do
+      playlist.name.should eq "Megaplaylist"
+    end
+
+    it "returns an empty string when the playlist is not loaded" do
+      empty_playlist.name.should be_empty
+    end
+  end
+
+  describe "#owner" do
+    it "returns the playlist’s owner" do
+      playlist.owner.should eq Hallon::User.new(mock_user)
+    end
+
+    it "returns nil when the playlist is not loaded" do
+      empty_playlist.owner.should be_nil
+    end
+  end
+
+  describe "#description" do
+    it "returns the playlist’s description" do
+      playlist.description.should eq "Playlist description...?"
+    end
+
+    it "returns an empty string if the playlist is not loaded" do
+      empty_playlist.description.should be_empty
+    end
+  end
+
+  describe "#image" do
+    it "returns the playlists’s image as an image" do
+      playlist.image.should eq Hallon::Image.new("spotify:image:3ad93423add99766e02d563605c6e76ed2b0e400")
+    end
+
+    it "returns nil if the playlist is not loaded" do
+      empty_playlist.image.should be_nil
+    end
+  end
+
+  describe "#total_subscribers" do
+    it "returns the total number of subscribers to the playlist" do
+      playlist.total_subscribers.should eq 1000
+    end
+
+    it "returns zero if the playlist is not loaded" do
+      empty_playlist.total_subscribers.should eq 0
+    end
+  end
+
+  describe "#sync_progress" do
+    it "returns the completed percentage of the playlist download" do
+      playlist.sync_progress.should eq 67
+    end
+
+    it "returns zero if the playlist is not loaded" do
+      empty_playlist.sync_progress.should eq 0
+    end
+  end
+
+  describe "#size" do
+    it "returns the number of tracks in the playlist" do
+      playlist.size.should eq 4
+    end
+
+    it "returns zero if the playlist is not loaded" do
+      empty_playlist.size.should eq 0
+    end
+  end
+
+  describe "#collaborative?" do
+    it "is true when the playlist is set to be collaborative" do
+      playlist.should be_collaborative
+    end
+  end
+
+  describe "#pending?" do
+    it "is false when the playlist does not have pending updates" do
+      playlist.should_not be_pending
+    end
+  end
+
+  describe "#in_ram?" do
+    it "is true when the playlist is loaded in memory" do
+      playlist.should be_in_ram
+    end
+  end
+
+  describe "#available_offline?" do
+    it "is false when the playlist is not enabled for offline use" do
+      playlist.should_not be_available_offline
+    end
+  end
+
+  describe "#tracks" do
+    it "returns an enumerator of the playlist’s tracks" do
+      playlist.tracks.to_a.should eq instantiate(Hallon::Playlist::Track, *(0...4).map { |index| [Spotify.playlist_track!(playlist.pointer, index), playlist.pointer, index] })
+    end
+
+    it "returns an empty enumerator if the playlist has no tracks" do
+      empty_playlist.tracks.should be_empty
+    end
+  end
+
+  describe "#tracks entries" do
+    let(:track) do
+      playlist.tracks[0]
+    end
+
+    let(:empty_track) do
+      playlist.tracks[3]
+    end
+
+    describe "#seen?" do
+      it "returns true if the track is seen" do
+        track.should be_seen
+      end
+    end
+
+    describe "#create_time" do
+      it "returns the time the track was added to the playlist" do
+        track.added_at.should eq Time.parse("2009-11-04")
+      end
 
-  its(:name)  { should eq "Megaplaylist" }
-  its(:owner) { should eq Hallon::User.new(mock_user) }
-  its(:description) { should eq "Playlist description...?" }
-  its(:image) { stub_session { should eq Hallon::Image.new(mock_image_id) } }
-  its(:total_subscribers) { should eq 1000 }
-  its(:sync_progress) { stub_session { should eq 67 } }
-  its(:size) { should eq 4 }
+      it "returns the time in UTC" do
+        track.added_at.utc_offset.should eq 0
+      end
+    end
 
-  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.pointer, index] }) }
+    describe "#creator" do
+      it "returns the track’s creator" do
+        track.adder.should eq Hallon::User.new(mock_user)
+      end
 
-  describe "tracks#[]" do
-    let(:track) { subject }
-    subject { playlist.tracks[0] }
+      it "returns nil if there is no track creator available" do
+        empty_track.adder.should be_nil
+      end
+    end
 
-    it { should be_seen }
-    its(:create_time) { should eq Time.parse("2009-11-04") }
-    its(:creator)     { should eq Hallon::User.new(mock_user) }
-    its(:message)     { should eq "message this, YO!" }
+    describe "#message" do
+      it "returns the message attached to the track" do
+        track.message.should eq "message this, YO!"
+      end
+
+      it "returns an empty message if there is none for the given track" do
+        empty_track.message.should be_empty
+      end
+    end
 
     describe "#seen=" do
       it "should raise an error if the track has moved" do
@@ -78,34 +214,33 @@ describe Hallon::Playlist do
     end
   end
 
-  describe "#upload", :stub_session do
+  describe "#upload" do
     around(:each) do |example|
-      Timeout.timeout(1) { example.run }
+      Timeout.timeout(1, SlowTestError, &example)
     end
 
     it "should raise an error if the playlist takes too long to load" do
       playlist.stub(:pending? => true)
-      expect { playlist.upload(0.01) }.to raise_error(Hallon::TimeoutError)
+      expect { playlist.upload(0.1) }.to raise_error(Hallon::TimeoutError)
     end
   end
 
   describe "#subscribers" do
     it "should return an array of names for the subscribers" do
-      subject.subscribers.should eq %w[Kim Elin Ylva]
+      playlist.subscribers.should eq %w[Kim Elin Ylva]
     end
 
     it "should return an empty array when there are no subscribers" do
       Spotify.should_receive(:playlist_subscribers).and_return(mock_empty_subscribers)
-      subject.subscribers.should eq []
+      playlist.subscribers.should eq []
     end
 
-    it "should return nil when subscriber fetching failed" do
-      Spotify.should_receive(:playlist_subscribers).and_return(null_pointer)
-      playlist.subscribers.should be_nil
+    it "should return an empty array when subscriber fetching failed" do
+      empty_playlist.subscribers.should eq []
     end
   end
 
-  describe "#insert", :stub_session do
+  describe "#insert" do
     let(:tracks) { instantiate(Hallon::Track, mock_track, mock_track_two) }
 
     it "should add the given tracks to the playlist at correct index" do
@@ -192,7 +327,7 @@ describe Hallon::Playlist do
     end
   end
 
-  describe "#in_ram=", :stub_session do
+  describe "#in_ram=" do
     it "should set in_ram status" do
       playlist.should be_in_ram
       playlist.in_ram = false
@@ -200,7 +335,7 @@ describe Hallon::Playlist do
     end
   end
 
-  describe "#offline_mode=", :stub_session do
+  describe "#offline_mode=" do
     it "should set offline mode" do
       playlist.should_not be_available_offline
       playlist.offline_mode = true
@@ -208,7 +343,7 @@ describe Hallon::Playlist do
     end
   end
 
-  describe "#update_subscribers", :stub_session do
+  describe "#update_subscribers" do
     it "should ask libspotify to update the subscribers" do
       expect { playlist.update_subscribers }.to_not raise_error
     end
@@ -218,29 +353,29 @@ describe Hallon::Playlist do
     end
   end
 
-  describe "offline status methods", :stub_session do
+  describe "offline status methods" 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)
-      should be_available_offline
+      playlist.should be_available_offline
     end
 
     specify "#syncing?" do
       Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(2)
-      should be_syncing
+      playlist.should be_syncing
     end
 
     specify "#waiting?" do
       Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(3)
-      should be_waiting
+      playlist.should be_waiting
     end
 
     specify "#offline_mode?" do
       Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(0)
-      should_not be_offline_mode
+      playlist.should_not be_offline_mode
     end
   end
 end