hallon 0.15.0 → 0.16.0

data/spec/hallon/search_spec.rb

@@ -2,27 +2,31 @@
 require 'cgi'
 
 describe Hallon::Search do
-  it_should_behave_like "a Linkable object" do
-    let(:spotify_uri) { "spotify:search:my+%C3%A5+utf8+%EF%A3%BF+query" }
-    let(:custom_object) { "http://open.spotify.com/search/my+%C3%A5+utf8+%EF%A3%BF+query" }
-    let(:described_class) { stub_session(Hallon::Search) }
+  let(:search) do
+    Hallon::Search.new("my å utf8  query")
   end
 
-  it { should be_a Hallon::Loadable }
+  let(:empty_search) do
+    Hallon::Search.new("")
+  end
 
-  subject { search }
-  let(:search) do
-    mock_session { Hallon::Search.new("my å utf8  query") }
+  specify { search.should be_a Hallon::Loadable }
+  specify { search.should be_a Hallon::Observable }
+
+  it_should_behave_like "a Linkable object" do
+    let(:spotify_uri) { "spotify:search:my+%C3%A5+utf8+%EF%A3%BF+query" }
+    let(:custom_object) { "http://open.spotify.com/search/my+%C3%A5+utf8+%EF%A3%BF+query" }
+    let(:described_class) { Hallon::Search }
   end
 
   describe ".new" do
     it "should have some sane defaults" do
       Spotify.should_receive(:search_create).with(session.pointer, "my å utf8  query", 0, 25, 0, 25, 0, 25, 0, 25, :standard, anything, anything).and_return(mock_search)
-      mock_session { Hallon::Search.new("my å utf8  query") }
+      Hallon::Search.new("my å utf8  query")
     end
 
     it "should allow you to customize the defaults" do
-      Spotify.should_receive(:search_create).with(session.pointer, "my å utf8  query", 1, 2, 3, 4, 5, 6, 7, 8, :standard, anything, anything).and_return(mock_search)
+      Spotify.should_receive(:search_create).with(session.pointer, "my å utf8  query", 1, 2, 3, 4, 5, 6, 7, 8, :suggest, anything, anything).and_return(mock_search)
       my_params = {
         :tracks_offset  => 1,
         :tracks         => 2,
@@ -31,35 +35,214 @@ describe Hallon::Search do
         :artists_offset => 5,
         :artists        => 6,
         :playlists_offset => 7,
-        :playlists      => 8
+        :playlists      => 8,
+        :type           => :suggest
       }
 
-      mock_session { Hallon::Search.new("my å utf8  query", my_params) }
+      Hallon::Search.new("my å utf8  query", my_params)
+    end
+
+    it "should raise an error given an invalid search type" do
+      expect { Hallon::Search.new("my å utf8  query", type: :hulabandola) }.to raise_error(ArgumentError)
     end
 
     it "should raise an error if the search failed" do
       Spotify.should_receive(:search_create).and_return(null_pointer)
-      expect { mock_session { Hallon::Search.new("omgwtfbbq") } }.to raise_error(/search (.*?) failed/)
+      expect { Hallon::Search.new("omgwtfbbq") }.to raise_error(/search (.*?) failed/)
+    end
+  end
+
+  describe "#loaded?" do
+    it "returns true if the search is complete" do
+      search.should be_loaded
+    end
+  end
+
+  describe "#status" do
+    it "returns the status of the search" do
+      search.status.should eq :ok
+    end
+  end
+
+  describe "#query" do
+    it "returns the search query" do
+      search.query.should eq "my å utf8  query"
+    end
+  end
+
+  describe "#did_you_mean" do
+    it "returns a suggestion for what the query might have intended to be" do
+      search.did_you_mean.should eq "another thing"
+    end
+
+    it "returns an empty string if there is no suggestion available" do
+      empty_search.did_you_mean.should be_empty
+    end
+  end
+
+  describe "#tracks" do
+    it "returns an enumerator of the search’s track" do
+      search.tracks.to_a.should eq instantiate(Hallon::Track, mock_track, mock_track_two)
+    end
+
+    it "returns an empty enumerator if there are no search results" do
+      empty_search.tracks.should be_empty
+    end
+
+    describe ".total" do
+      it "returns the total number of track search results" do
+        search.tracks.total.should eq 1337
+      end
+
+      it "returns zero if there are no search results whatsoever" do
+        empty_search.tracks.total.should eq 0
+      end
+    end
+  end
+
+  describe "#albums" do
+    it "returns an enumerator of the search’s albums" do
+      search.albums.to_a.should eq instantiate(Hallon::Album, mock_album)
+    end
+
+    it "returns an empty enumerator if there are no search results" do
+      empty_search.albums.should be_empty
+    end
+
+    describe ".total" do
+      it "returns the total number of album search results" do
+        search.albums.total.should eq 42
+      end
+
+      it "returns zero if there are no search results whatsoever" do
+        empty_search.albums.total.should eq 0
+      end
+    end
+  end
+
+  describe "#artists" do
+    it "returns an enumerator of the search’s artists" do
+      search.artists.to_a.should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two)
+    end
+
+    it "returns an empty enumerator if there are no search results" do
+      empty_search.artists.should be_empty
+    end
+
+    describe ".total" do
+      it "returns the total number of artist search results" do
+        search.artists.total.should eq 81104
+      end
+
+      it "returns zero if there are no search results whatsoever" do
+        empty_search.artists.total.should eq 0
+      end
+    end
+  end
+
+  describe "#playlist_names" do
+    it "returns an enumerator of the search’s playlist names" do
+      search.playlist_names.to_a.should eq %w(Dunderlist)
+    end
+
+    it "returns an empty enumerator of there are no search results" do
+      empty_search.playlist_names.should be_empty
+    end
+
+    describe ".total" do
+      it "returns the total number of search results" do
+        search.playlist_names.total.should eq 462
+      end
+
+      it "returns zero if there are no search results whatsoever" do
+        empty_search.playlist_names.total.should eq 0
+      end
+    end
+  end
+
+  describe "#playlist_uris" do
+    it "returns an enumerator of the search’s playlist uris" do
+      search.playlist_uris.to_a.should eq %w(spotify:user:burgestrand:playlist:megaplaylist)
+    end
+
+    it "returns an empty enumerator of there are no search results" do
+      empty_search.playlist_uris.should be_empty
+    end
+
+    describe ".total" do
+      it "returns the total number of search results" do
+        search.playlist_uris.total.should eq 462
+      end
+
+      it "returns zero if there are no search results whatsoever" do
+        empty_search.playlist_uris.total.should eq 0
+      end
     end
   end
 
-  it { should be_a Hallon::Observable }
-  it { should be_loaded }
-  its(:status) { should eq :ok }
-  its(:query) { should eq "my å utf8  query" }
-  its(:did_you_mean) { should eq "another thing" }
+  describe "#playlist_image_uris" do
+    it "returns an enumerator of the search’s playlist image uris" do
+      search.playlist_image_uris.to_a.should eq %w(spotify:image:3ad93423add99766e02d563605c6e76ed2b0e400)
+    end
+
+    it "returns an empty enumerator of there are no search results" do
+      empty_search.playlist_image_uris.should be_empty
+    end
+
+    describe ".total" do
+      it "returns the total number of search results" do
+        search.playlist_image_uris.total.should eq 462
+      end
+
+      it "returns zero if there are no search results whatsoever" do
+        empty_search.playlist_image_uris.total.should eq 0
+      end
+    end
+  end
+
+  describe "#playlists" do
+    it "returns an enumerator of the search’s playlists" do
+      search.playlists.to_a.should eq instantiate(Hallon::Playlist, mock_playlist_two)
+    end
+
+    it "returns an empty enumerator of there are no search results" do
+      empty_search.playlists.should be_empty
+    end
 
-  its('tracks.size')  { should eq 2 }
-  its('tracks.to_a')  { should eq instantiate(Hallon::Track, mock_track, mock_track_two) }
-  its('tracks.total') { should eq 1337 }
+    describe ".total" do
+      it "returns the total number of search results" do
+        search.playlists.total.should eq 462
+      end
 
-  its('albums.size')  { should eq 1 }
-  its('albums.to_a')  { should eq instantiate(Hallon::Album, mock_album) }
-  its('albums.total') { should eq 42 }
+      it "returns zero if there are no search results whatsoever" do
+        empty_search.playlists.total.should eq 0
+      end
+    end
+  end
+
+  describe "#playlist_images" do
+    it "returns an enumerator of the search’s playlist images" do
+      search.playlist_images.to_a.should eq instantiate(Hallon::Image, mock_image)
+    end
+
+    it "returns an empty enumerator of there are no search results" do
+      empty_search.playlist_images.should be_empty
+    end
 
-  its('artists.size')  { should eq 2 }
-  its('artists.to_a')  { should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two) }
-  its('artists.total') { should eq 81104 }
+    describe ".total" do
+      it "returns the total number of search results" do
+        search.playlist_images.total.should eq 462
+      end
 
-  its(:to_link) { should eq Hallon::Link.new("spotify:search:#{CGI.escape(search.query)}") }
+      it "returns zero if there are no search results whatsoever" do
+        empty_search.playlist_images.total.should eq 0
+      end
+    end
+  end
+
+  describe "#to_link" do
+    it "contains the search query" do
+      search.to_link.should eq Hallon::Link.new("spotify:search:#{CGI.escape(search.query)}")
+    end
+  end
 end

data/spec/hallon/session_spec.rb

@@ -68,35 +68,6 @@ describe Hallon::Session do
     end
   end
 
-  describe "#process_events_on" do
-    it "should not call given block on :notify_main_thread implicitly" do
-      notified = false
-
-      session.should_receive(:process_events).twice.and_return do
-        unless notified
-          session.class.send(:notify_main_thread_callback, session.pointer)
-          notified = true
-        else
-          session.class.send(:logged_in_callback, session.pointer, :ok)
-        end
-
-        0
-      end
-
-      session.process_events_on(:logged_in) { |e| e == :ok }.should be_true
-    end
-
-    it "should time out if waiting for events too long" do
-      session.should_receive(:process_events).once.and_return(1) # and do nothing
-      session.wait_for(:logged_in) { |x| x }.should eq :timeout
-    end
-
-    it "should call the given block once before waiting" do
-      session.should_not_receive(:process_events)
-      session.process_events_on { true }
-    end
-  end
-
   describe "#relogin" do
     it "should raise if no credentials have been saved" do
       expect { session.relogin }.to raise_error(Hallon::Error)
@@ -135,6 +106,16 @@ describe Hallon::Session do
       expect { session.login '', 'pass' }.to raise_error(ArgumentError)
       expect { session.login 'Kim', '' }.to raise_error(ArgumentError)
     end
+
+    it "should login with a blob when given a blob" do
+      Spotify.should_receive(:session_login).with(anything, 'Kim', nil, false, 'blob')
+      session.login 'Kim', Hallon::Blob('blob')
+    end
+
+    it "should not login with a blob when not given a blob" do
+      Spotify.should_receive(:session_login).with(anything, 'Kim', 'pass', false, nil)
+      session.login 'Kim', 'pass'
+    end
   end
 
   describe "#logout" do
@@ -232,16 +213,35 @@ describe Hallon::Session do
   end
 
   describe "offline settings readers" do
-    subject { mock_session_object }
+    let(:session) { mock_session_object }
 
-    its(:offline_time_left) { should eq 60 * 60 * 24 * 30 } # a month!
-    its(:offline_sync_status) { should eq mock_offline_sync_status_hash }
-    its(:offline_playlists_count) { should eq 7 }
-    its(:offline_tracks_to_sync) { should eq 3 }
+    describe "#offline_time_left" do
+      it "returns the time left until libspotify must go online" do
+        session.offline_time_left.should eq 60 * 60 * 24 * 30
+      end
+    end
+
+    describe "#offline_sync_status" do
+      it "returns a hash of offline sync status details" do
+        session.offline_sync_status.should eq mock_offline_sync_status_hash
+      end
+
+      it "returns an empty hash when offline sync status details are unavailable" do
+        Spotify.should_receive(:offline_sync_get_status).and_return(false)
+        session.offline_sync_status.should eq Hash.new
+      end
+    end
 
-    specify "offline_sync_status when given false as return from libspotify" do
-      Spotify.should_receive(:offline_sync_get_status).and_return(false)
-      subject.offline_sync_status.should eq nil
+    describe "#offline_playlists_count" do
+      it "returns the number of playlists marked for offline synchronization" do
+        session.offline_playlists_count.should eq 7
+      end
+    end
+
+    describe "#offline_tracks_to_sync" do
+      it "returns the number of tracks that still need to be synchronized" do
+        session.offline_tracks_to_sync.should eq 3
+      end
     end
   end
 
@@ -267,7 +267,7 @@ describe Hallon::Session do
 
 
   describe "#starred" do
-    let(:starred) { mock_session { Hallon::Playlist.new("spotify:user:burgestrand:starred") } }
+    let(:starred) { Hallon::Playlist.new("spotify:user:burgestrand:starred") }
 
     it "should return the sessions (current users) starred playlist" do
       session.login 'burgestrand', 'pass'
@@ -298,4 +298,10 @@ describe Hallon::Session do
       session.inbox.should be_nil
     end
   end
+
+  describe "#flush_caches" do
+    it "flushes the session cache to disk" do
+      session.flush_caches # or, actually, it does not crash
+    end
+  end
 end

data/spec/hallon/toplist_spec.rb

@@ -1,36 +1,50 @@
-describe Hallon::Toplist do
-  it { should be_a Hallon::Loadable }
+# coding: utf-8
 
+describe Hallon::Toplist do
   let(:toplist) do
     Spotify.registry_add 'spotify:toplist:artists:everywhere', mock_toplistbrowse
-    mock_session { Hallon::Toplist.new(:artists) }
+    Hallon::Toplist.new(:artists)
+  end
+
+  let(:empty_toplist) do
+    Spotify.registry_add 'spotify:toplist:tracks:everywhere', mock_empty_toplistbrowse
+    Hallon::Toplist.new(:tracks)
   end
-  subject { toplist }
 
-  it { should be_a Hallon::Observable }
+  specify { toplist.should be_a Hallon::Loadable }
+  specify { toplist.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/)
+      expect { 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 }
+      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 }
+      Hallon::Toplist.new(:tracks, :se).should be_loaded
     end
   end
 
-  it { should be_loaded }
-  its(:status) { should eq :ok }
+  describe "#loaded?" do
+    it "returns true if the toplist is loaded" do
+      toplist.should be_loaded
+    end
+  end
+
+  describe "#status" do
+    it "returns the toplist’s status" do
+      toplist.status.should eq :ok
+    end
+  end
 
   describe "#type" do
     it "should be the same as the type given to .new" do
-      toplist = mock_session { Hallon::Toplist.new(:tracks, :se) }
+      toplist = Hallon::Toplist.new(:tracks, :se)
       toplist.type.should eq :tracks
     end
   end
@@ -50,6 +64,10 @@ describe Hallon::Toplist do
       toplist.should_receive(:type).and_return(:tracks)
       toplist.results.to_a.should eq instantiate(Hallon::Track, mock_track, mock_track_two)
     end
+
+    it "returns an empty enumerator when there are no results" do
+      empty_toplist.results.should be_empty
+    end
   end
 
   describe "#request_duration" do
@@ -57,9 +75,8 @@ describe Hallon::Toplist do
       toplist.request_duration.should eq 2.751
     end
 
-    it "should be nil if the request was fetched from local cache" do
-      Spotify.should_receive(:toplistbrowse_backend_request_duration).and_return(-1)
-      toplist.request_duration.should be_nil
+    it "should be zero if the request was fetched from local cache" do
+      empty_toplist.request_duration.should eq 0
     end
   end
 end