hallon 0.4.0 → 0.8.0

data/spec/hallon/error_spec.rb

@@ -35,6 +35,16 @@ describe Hallon::Error do
     it "should return the error symbol if it's ok" do
       subject.maybe_raise(0).should eq :ok
     end
+
+    # to account for the following case:
+    # session.wait_for(:timeout) { |param| Hallon::Error.maybe_raise(param) }
+    it "should return nil when the error is nil" do
+      subject.maybe_raise(nil).should eq nil
+    end
+
+    it "should return nil when the error is timeout" do
+      subject.maybe_raise(:timeout).should eq nil
+    end
   end
 
   describe "::table" do

data/spec/hallon/hallon_spec.rb

@@ -4,7 +4,11 @@ describe Hallon do
   end
 
   describe "API_VERSION" do
-    specify { Hallon::API_VERSION.should == 8 }
+    specify { Hallon::API_VERSION.should == 9 }
+  end
+
+  describe "API_BUILD" do
+    specify { Hallon::API_BUILD.should be_a String }
   end
 
   describe "URI" do

data/spec/hallon/image_spec.rb

@@ -1,13 +1,10 @@
 # coding: utf-8
-describe Hallon::Image, :session => true do
+describe Hallon::Image do
   describe "an image instance" do
-    let(:image) do
-      Hallon::Session.should_receive(:instance).and_return session
-      Hallon::Image.new(mock_image)
-    end
-
     subject { image }
+    let(:image) { mock_session { Hallon::Image.new(mock_image) } }
 
+    it { should be_loaded }
     its(:status) { should be :ok }
     its(:format) { should be :jpeg }
 
@@ -34,34 +31,51 @@ describe Hallon::Image, :session => true do
         image.to_link.should eq Hallon::Link.new("spotify:image:#{image.id}")
       end
     end
-  end
 
-  context "created from an url" do
-    subject { Hallon::Image.new("http://open.spotify.com/image/c78f091482e555bd2ffacfcd9cbdc0714b221663", session) }
-    its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
-  end
+    describe "#==" do
+      it "should not fail given an object that does not respond to id" do
+        o = Object.new
+        def o.id
+          raise NoMethodError
+        end
 
-  context "created from an uri" do
-    subject { Hallon::Image.new("spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663", session) }
-    its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
+        image.should_not eq o
+      end
+    end
   end
 
-  context "created from an id" do
-    subject { Hallon::Image.new(mock_image_id, session) }
-    its(:id) { should eq mock_image_hex }
-  end
+  describe "instantiation" do
+    subject do
+      mock_session do
+        Hallon::Image.new(image_uri)
+      end
+    end
 
-  context "created from a link" do
-    subject { Hallon::Image.new(Hallon::Link.new("spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663"), session) }
-    its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
+    context "created from an url" do
+      let(:image_uri) { "http://open.spotify.com/image/c78f091482e555bd2ffacfcd9cbdc0714b221663" }
+      its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
+    end
+
+    context "created from an uri" do
+      let(:image_uri) { "spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663" }
+      its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
+    end
+
+    context "created from an id" do
+      let(:image_uri) { mock_image_id }
+      its(:id) { should eq mock_image_hex }
+    end
+
+    context "created from a link" do
+      let(:image_uri) { Hallon::Link.new("spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663") }
+      its(:id) { should eq "c78f091482e555bd2ffacfcd9cbdc0714b221663" }
+    end
   end
 
   describe "callbacks" do
-    it "should trigger :load when loaded" do
-      pending "waiting for mockspotify event system"
-
+    it "should trigger :load when loaded", :pending => true do
       uri = "spotify:image:c78f091482e555bd2ffacfcd9cbdc0714b221663"
-      image = Hallon::Image.new(uri, session)
+      image = Hallon::Image.new(uri)
       image.should_not be_loaded
       image.should_receive(:trigger).with(:load).once
 

data/spec/hallon/linkable_spec.rb

@@ -8,6 +8,7 @@ describe Hallon::Linkable do
   end
 
   let(:object) { klass.new }
+  let(:pointer) { FFI::Pointer.new(1) }
 
   before(:each) { Spotify.stub(:link_as_search) }
 
@@ -19,7 +20,7 @@ describe Hallon::Linkable do
 
   describe "#from_link" do
     it "should call the appropriate Spotify function" do
-      Spotify.should_receive(:link_as_search)
+      Spotify.should_receive(:link_as_search).and_return(pointer)
 
       klass.from_link(:as_search)
       object.from_link 'spotify:search:moo'
@@ -29,13 +30,20 @@ describe Hallon::Linkable do
       Spotify.should_not_receive(:link_as_search)
 
       called = false
-      klass.from_link(:as_search) { called = true }
+      klass.from_link(:as_search) { called = true and pointer }
       expect { object.from_link 'spotify:search:whatever' }.to change { called }
     end
 
     it "should pass extra parameters to the defining block" do
-      klass.from_link(:search) { |link, *args| args }
-      object.from_link("spotify:search:burgestrand", :cool, 5).should eq [:cool, 5]
+      passed_args = nil
+      klass.from_link(:search) { |link, *args| passed_args = args and pointer }
+      object.from_link("spotify:search:burgestrand", :cool, 5)
+      passed_args.should eq [:cool, 5]
+    end
+
+    it "should fail, given a null pointer" do
+      klass.from_link(:as_search)
+      expect { object.from_link FFI::Pointer.new(0) }.to raise_error(Hallon::Error)
     end
   end
 end

data/spec/hallon/observable_spec.rb

@@ -29,6 +29,11 @@ describe Hallon::Observable do
       subject.on(:a) { |event, *args| event }
       subject.trigger(:a).should eq nil
     end
+
+    it "should convert the event to a symbol" do
+      subject.on("a") { raise "hell" }
+      expect { subject.trigger(:a) }.to raise_error("hell")
+    end
   end
 
   describe "#trigger and #on" do

data/spec/hallon/player_spec.rb

@@ -0,0 +1,73 @@
+describe Hallon::Player do
+  let(:player) { Hallon::Player.new(session) }
+  let(:track) { Hallon::Track.new(mock_track) }
+
+  describe ".bitrates" do
+    it "should be a list of symbols in ascending order" do
+      Hallon::Player.bitrates.should eq %w[96k 160k 320k].map(&:to_sym)
+    end
+  end
+
+  describe "#bitrate=" do
+    it "should not fail horribly given a correct bitrate" do
+      player.bitrate = :'96k'
+    end
+
+    it "should fail horrible given a bad bitrate" do
+      expect { player.bitrate = :'100k' }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#load" do
+    it "should load the given track" do
+      Spotify.should_receive(:session_player_load).with(session.pointer, track.pointer)
+      player.load(track)
+    end
+
+    it "should raise an error if load was unsuccessful" do
+      Spotify.should_receive(:session_player_load).and_return(:track_not_playable)
+      expect { player.load(track) }.to raise_error(Hallon::Error, /TRACK_NOT_PLAYABLE/)
+    end
+  end
+
+  describe "#stop" do
+    it "should unload the currently loaded track" do
+      Spotify.should_receive(:session_player_unload).with(session.pointer)
+      player.stop
+    end
+  end
+
+  describe "#prefetch" do
+    it "should set up given track for prefetching" do
+      Spotify.should_receive(:session_player_prefetch).with(session.pointer, track.pointer)
+      player.prefetch(track)
+    end
+  end
+
+  describe "#play" do
+    it "should start playback of given track" do
+      Spotify.should_receive(:session_player_play).with(session.pointer, true)
+      player.play
+    end
+
+    it "should load and play given track if one was given" do
+      Spotify.should_receive(:session_player_load).with(session.pointer, track.pointer)
+      Spotify.should_receive(:session_player_play).with(session.pointer, true)
+      player.play(track)
+    end
+  end
+
+  describe "#pause" do
+    it "should stop playback of given track" do
+      Spotify.should_receive(:session_player_play).with(session.pointer, false)
+      player.pause
+    end
+  end
+
+  describe "#seek" do
+    it "should set up the currently loaded track at given position" do
+      Spotify.should_receive(:session_player_seek).with(session.pointer, 1000)
+      player.seek(1)
+    end
+  end
+end

data/spec/hallon/search_spec.rb

@@ -0,0 +1,80 @@
+describe Hallon::Search do
+  subject { search }
+  let(:search) do
+    mock_session do
+      Spotify.should_receive(:search_create).and_return(mock_search)
+      Hallon::Search.new("my query")
+    end
+  end
+
+  describe ".new" do
+    it "should have some sane defaults" do
+      Spotify.should_receive(:search_create).with(session.pointer, "my query", 0, 25, 0, 25, 0, 25, anything, anything).and_return(mock_search)
+      mock_session { Hallon::Search.new("my query") }
+    end
+
+    it "should allow you to customize the defaults" do
+      Spotify.should_receive(:search_create).with(session.pointer, "my query", 1, 2, 3, 4, 5, 6, anything, anything).and_return(mock_search)
+      my_params = {
+        :tracks_offset  => 1,
+        :tracks         => 2,
+        :albums_offset  => 3,
+        :albums         => 4,
+        :artists_offset => 5,
+        :artists        => 6
+      }
+
+      mock_session { Hallon::Search.new("my query", my_params) }
+    end
+  end
+
+  describe ".genres" do
+    subject { Hallon::Search.genres }
+
+    it { should include :jazz }
+    it { should be_a Array }
+    it { should_not be_empty }
+  end
+
+  describe ".search" do
+    subject do
+      Spotify.should_receive(:radio_search_create).and_return(mock_search)
+
+      mock_session do
+        search = Hallon::Search.radio(1990..2010, :jazz, :punk)
+      end
+    end
+
+    it "should simply ignore invalid genres" do
+      mock_session do
+        Spotify.should_receive(:radio_search_create).and_return(mock_search)
+        expect { Hallon::Search.radio(1990..2010, :bogus, :hocum) }.to_not raise_error
+      end
+    end
+
+    it { should be_loaded }
+    its(:error) { should eq :ok }
+    its('tracks.size') { should eq 2 }
+    # ^ should be enough
+  end
+
+  it { should be_a Hallon::Observable }
+  it { should be_loaded }
+  its(:error) { should eq :ok }
+  its(:query) { should eq "my query" }
+  its(:did_you_mean) { should eq "another thing" }
+
+  its('tracks.size')  { should eq 2 }
+  its('tracks.to_a')  { should eq instantiate(Hallon::Track, mock_track, mock_track_two) }
+  its('total_tracks') { should eq 1337 }
+
+  its('albums.size')  { should eq 1 }
+  its('albums.to_a')  { should eq instantiate(Hallon::Album, mock_album) }
+  its('total_albums') { should eq 42 }
+
+  its('artists.size')  { should eq 2 }
+  its('artists.to_a')  { should eq instantiate(Hallon::Artist, mock_artist, mock_artist_two) }
+  its('total_artists') { should eq 81104 }
+
+  its(:to_link) { should eq Hallon::Link.new("spotify:search:#{search.query}") }
+end

data/spec/hallon/session_spec.rb

@@ -2,13 +2,27 @@
 describe Hallon::Session do
   it { Hallon::Session.should_not respond_to :new }
 
-  describe "#instance" do
+  describe ".initialize and .instance" do
+    before { Hallon.instance_eval { @__instance = nil } }
+    after  { Hallon.instance_eval { @__instance = nil } }
+
+    it "should fail if calling instance before initialize" do
+      expect { Hallon.instance }.to raise_error
+    end
+
+    it "should fail if calling initialize twice" do
+      expect {
+        Hallon.initialize
+        Hallon.initialize
+      }.to raise_error
+    end
+  end
+
+  describe ".new" do
     it "should require an application key" do
       expect { Hallon::Session.send(:new) }.to raise_error(ArgumentError)
     end
-  end
 
-  describe "#new" do
     it "should fail on an invalid application key" do
       expect { create_session(false) }.to raise_error(Hallon::Error, /BAD_APPLICATION_KEY/)
     end
@@ -52,12 +66,50 @@ describe Hallon::Session do
         end
       end
 
-      session.process_events_on(:bogus) { |e| e.inspect }.should eq ":bogus"
+      session.process_events_on(:bogus) { |e| e == :bogus }.should be_true
     end
 
     it "should time out if waiting for events too long" do
-      session.should_receive(:process_events).once.and_return { session.trigger(:whatever) }
-      session.process_events_on(:whatever) { |e| e.inspect }.should eq "nil"
+      session.should_receive(:process_events).once # and do nothing
+      session.wait_for(:ever) { |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)
+    end
+
+    it "should not raise if credentials have been saved" do
+      session.login 'Kim', 'pass', true
+      session.logout
+      expect { session.relogin }.to_not raise_error
+      session.should be_logged_in
+    end
+  end
+
+  describe "#remembered_user" do
+    it "should be nil if no username is stored in libspotify" do
+      session.remembered_user.should eq nil
+    end
+
+    it "should retrieve the remembered username if stored" do
+      session.login 'Kim', 'pass', true
+      session.remembered_user.should eq 'Kim'
+    end
+  end
+
+  describe "#forget_me!" do
+    it "should forget the currently stored user credentials" do
+      session.login 'Kim', 'pass', true
+      session.remembered_user.should eq 'Kim'
+      session.forget_me!
+      session.remembered_user.should eq nil
     end
   end
 
@@ -68,6 +120,135 @@ describe Hallon::Session do
     end
   end
 
+  describe "#country" do
+    it "should retrieve the current sessions’ country as a string" do
+      session.country.should eq 'SE'
+    end
+  end
+
+  describe "#star and #unstar" do
+    it "should be able to star and unstar tracks" do
+      # for track#starred?
+      Hallon::Session.should_receive(:instance).exactly(6).times.and_return(session)
+
+      tracks = [mock_track, mock_track_two]
+      tracks.map! { |x| Hallon::Track.new(x) }
+      tracks.all?(&:starred?).should be_true # starred by default
+
+      session.unstar(*tracks)
+      tracks.none?(&:starred?).should be_true
+
+      session.star(tracks[0])
+      tracks[0].should be_starred
+      tracks[1].should_not be_starred
+    end
+  end
+
+  describe "#friends" do
+    let(:session) { mock_session_object }
+
+    it "should be an enumerator" do
+      session.friends.should be_an Hallon::Enumerator
+    end
+
+    it "should be empty if not logged in" do
+      Spotify.should_not_receive(:session_num_friends)
+      session.should_receive(:logged_in?).and_return(false)
+      session.friends.size.should eq 0
+    end
+
+    it "should be an enumerator of friends" do
+      session.login 'Kim', 'pass'
+      session.friends[0].should eq Hallon::User.new(mock_user)
+    end
+  end
+
+  describe "#cache_size" do
+    it "should default to 0" do
+      session.cache_size.should eq 0
+    end
+
+    it "should be settable" do
+      session.cache_size = 10
+      session.cache_size.should eq 10
+    end
+  end
+
+  describe ".connection_types" do
+    subject { Hallon::Session.connection_types }
+
+    it { should be_an Array }
+    it { should_not be_empty }
+    it { should include :wifi }
+  end
+
+  describe "#connection_type=" do
+    it "should fail given an invalid connection type" do
+      expect { session.connection_type = :bogus }.to raise_error(ArgumentError)
+    end
+
+    it "should succeed given a correct connection type" do
+      expect { session.connection_type = :wifi }.to_not raise_error
+    end
+  end
+
+  describe ".connection_types" do
+    subject { Hallon::Session.connection_rules }
+
+    it { should be_an Array }
+    it { should_not be_empty }
+    it { should include :network }
+  end
+
+  describe "#connection_rules=" do
+    it "should not fail given an invalid rule" do
+      expect { session.connection_rules = :lawly }.to_not raise_error
+    end
+
+    it "should succeed given correct connection thingy" do
+      expect { session.connection_rules = :allow_network, :allow_sync_over_mobile }.to_not raise_error
+    end
+
+    it "should combine given rules and feed to libspotify" do
+      Spotify.should_receive(:session_set_connection_rules).with(session.pointer, 5)
+      session.connection_rules = :network, :allow_sync_over_mobile
+    end
+  end
+
+  describe "offline settings readers" do
+    subject { 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 }
+
+    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
+    end
+  end
+
+  describe "#offline_bitrate=" do
+    it "should not resync unless explicitly told so" do
+      Spotify.should_receive(:session_preferred_offline_bitrate).with(session.pointer, :'96k', false)
+      session.offline_bitrate = :'96k'
+    end
+
+    it "should resync if asked to" do
+      Spotify.should_receive(:session_preferred_offline_bitrate).with(session.pointer, :'96k', true)
+      session.offline_bitrate = :'96k', true
+    end
+
+    it "should fail given an invalid value" do
+      expect { session.offline_bitrate = :hocum }.to raise_error(ArgumentError)
+    end
+
+    it "should succeed given a proper value" do
+      expect { session.offline_bitrate = :'96k' }.to_not raise_error
+    end
+  end
+
   context "when logged in", :logged_in => true do
     it "should be logged in" do
       session.should be_logged_in