hallon 0.8.0 → 0.9.0

data/spec/hallon/playlist_container_spec.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+describe Hallon::PlaylistContainer do
+  let(:container) { Hallon::PlaylistContainer.new(mock_container) }
+
+  subject { container }
+
+  it { should be_loaded }
+  its(:owner) { should eq Hallon::User.new("burgestrand") }
+
+  describe "#add" do
+    it "should create a new Playlist at the end of the playlist"
+  end
+
+  describe "#insert" do
+    it "should add the given Playlist to the given index"
+    it "should add the given Folder to the given index", :pending => true
+  end
+
+  describe "#remove" do
+    it "should remove the playlist at the given index"
+    it "should remove the matching :folder_end if removing a folder"
+  end
+
+  describe "#move" do
+    it "should move the entity at the given index"
+  end
+
+  describe "#contents" do
+    #
+    # (0) playlist: Hello
+    # (1) start_folder: Hi
+    # (2) playlist: inside Hi
+    # (3) start_folder: Ho
+    # (4) playlist: inside HiHo
+    # (5) end_folder
+    # (6) playlist: inside Hi2
+    # (7) end_folder
+    # (8) playlist: World
+    #
+    # … should become:
+    #
+    # (0) Playlist #1
+    # (1) Folder #1…#7
+    # (2) Playlist #2
+    # (3) Folder #3…#5
+    # (4) Playlist #4
+    # (5) Folder #3…#5
+    # (6) Playlist #6
+    # (7) Folder #1…#7
+    # (8) Playlist #8
+    #
+    it "should be a collection of folders and playlists"
+  end
+
+  describe "PlaylistContainer Playlists", :pending do
+    subject { container.contents[1] }
+
+    its(:name) { should be "Awesome playlist" }
+  end
+
+  describe Hallon::PlaylistContainer::Folder, :pending do
+    subject { container.contents[1] }
+
+    its(:id)   { should be 1337 }
+    its(:name) { should be "Awesome folder" }
+
+    describe "#contents" do
+      it "should be a collection of folders and playlists"
+    end
+
+    describe "#rename" do
+      it "should rename the playlist container"
+    end
+  end
+end

data/spec/hallon/playlist_spec.rb

@@ -0,0 +1,204 @@
+require 'time'
+
+describe Hallon::Playlist do
+  it_should_behave_like "a Linkable object" do
+    let(:spotify_uri) { "spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi" }
+    let(:described_class) do
+      real_session = session
+      Hallon::Playlist.dup.tap do |klass|
+        klass.class_eval do
+          define_method(:session) { real_session }
+        end
+      end
+    end
+  end
+
+  let(:playlist) { Hallon::Playlist.new(mock_playlist) }
+  subject { playlist }
+
+  it { should be_loaded }
+  it { should be_collaborative }
+  it { should_not be_pending }
+  it { mock_session { should be_in_ram } }
+  it { mock_session { should_not be_available_offline } }
+
+  its(:name)  { should eq "Megaplaylist" }
+  its(:owner) { should eq Hallon::User.new(mock_user) }
+  its(:description) { should eq "Playlist description...?" }
+  its(:image) { mock_session { should eq Hallon::Image.new(mock_image_id) } }
+  its(:total_subscribers) { should eq 1000 }
+  its(:sync_progress) { mock_session { should eq 67 } }
+  its(:size) { should eq 4 }
+
+  its('tracks.size') { should eq 4 }
+  its('tracks.to_a') { should eq instantiate(Hallon::Playlist::Track, [mock_playlist, 0], [mock_playlist, 1], [mock_playlist, 2], [mock_playlist, 3]) }
+  describe "tracks#[]" do
+    subject { playlist.tracks[0] }
+
+    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!" }
+  end
+
+  describe "#seen" do
+    it "should set the seen status of the track at the given index" do
+      track = playlist.tracks[0]
+      track.should be_seen
+
+      track = playlist.seen(0, false)
+      track.should_not be_seen
+
+      track = playlist.seen(0, true)
+      track.should be_seen
+    end
+  end
+
+  describe "#subscribers" do
+    it "should return an array of names for the subscribers" do
+      subject.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 []
+    end
+  end
+
+  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
+      old_tracks = playlist.tracks.to_a
+      new_tracks = old_tracks.insert(1, *tracks)
+      mock_session { playlist.insert(1, tracks) }
+
+      playlist.tracks.to_a.should eq new_tracks
+    end
+
+    it "should default to adding tracks at the end" do
+      mock_session { playlist.insert(tracks) }
+      playlist.tracks[2, 2].should eq tracks
+    end
+
+    it "should raise an error if the operation cannot be completed" do
+      expect { mock_session { playlist.insert(-1, nil) } }.to raise_error(Hallon::Error)
+    end
+  end
+
+  describe "#remove" do
+    it "should remove the tracks at the given indices" do
+      old_tracks = playlist.tracks.to_a
+      new_tracks = [old_tracks[0], old_tracks[2]]
+
+      playlist.remove(1, 3)
+      playlist.tracks.to_a.should eq new_tracks
+    end
+
+    it "should raise an error if the operation cannot be completed" do
+      expect { playlist.remove(-1) }.to raise_error(Hallon::Error)
+    end
+  end
+
+  describe "#move" do
+    it "should move the tracks at the given indices to their new location" do
+      old_tracks = playlist.tracks.to_a
+      new_tracks = [old_tracks[1], old_tracks[0], old_tracks[3], old_tracks[2]]
+
+      playlist.move(2, [0, 3])
+      playlist.tracks.to_a.should eq new_tracks
+    end
+
+    it "should raise an error if the operation cannot be completed" do
+      expect { playlist.move(-1, [-1]) }.to raise_error(Hallon::Error)
+    end
+  end
+
+  describe "#name=" do
+    it "should set the new playlist name" do
+      playlist.name.should eq "Megaplaylist"
+      playlist.name = "Monoplaylist"
+      playlist.name.should eq "Monoplaylist"
+    end
+
+    it "should fail given an empty name" do
+      expect { playlist.name = "" }.to raise_error(Hallon::Error)
+    end
+
+    it "should fail given a name of only spaces" do
+      expect { playlist.name = " " }.to raise_error(ArgumentError)
+    end
+
+    it "should fail given a too long name" do
+      expect { playlist.name = "a" * 256 }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#collaborative=" do
+    it "should set the collaborative status" do
+      playlist.should be_collaborative
+      playlist.collaborative = false
+      playlist.should_not be_collaborative
+    end
+  end
+
+  describe "#autolink_tracks=" do
+    it "should set autolink status" do
+      Spotify.mocksp_playlist_get_autolink_tracks(playlist.pointer).should be_false
+      playlist.autolink_tracks = true
+      Spotify.mocksp_playlist_get_autolink_tracks(playlist.pointer).should be_true
+    end
+  end
+
+  describe "#in_ram=" do
+    it "should set in_ram status" do
+      mock_session do
+        playlist.should be_in_ram
+        playlist.in_ram = false
+        playlist.should_not be_in_ram
+      end
+    end
+  end
+
+  describe "#offline_mode=" do
+    it "should set offline mode" do
+      mock_session do
+        playlist.should_not be_available_offline
+        playlist.offline_mode = true
+        playlist.should be_available_offline
+      end
+    end
+  end
+
+  describe "#update_subscribers" do
+    it "should ask libspotify to update the subscribers" do
+      expect { mock_session { playlist.update_subscribers } }.to_not raise_error
+    end
+  end
+
+  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)
+      mock_session { should be_available_offline }
+    end
+
+    specify "#syncing?" do
+      Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(2)
+      mock_session { should be_syncing }
+    end
+
+    specify "#waiting?" do
+      Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(3)
+      mock_session { should be_waiting }
+    end
+
+    specify "#offline_mode?" do
+      Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(0)
+      mock_session { should_not be_offline_mode }
+    end
+  end
+end

data/spec/hallon/search_spec.rb

@@ -1,10 +1,8 @@
 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
+    Spotify.registry_add 'spotify:search:my query', mock_search
+    mock_session { Hallon::Search.new("my query") }
   end
 
   describe ".new" do
@@ -26,6 +24,11 @@ describe Hallon::Search do
 
       mock_session { Hallon::Search.new("my query", my_params) }
     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/)
+    end
   end
 
   describe ".genres" do
@@ -36,31 +39,31 @@ describe Hallon::Search do
     it { should_not be_empty }
   end
 
-  describe ".search" do
+  describe ".radio" do
     subject do
-      Spotify.should_receive(:radio_search_create).and_return(mock_search)
+      Spotify.registry_add 'spotify:radio:00002200:1990-2010', mock_search
+      mock_session { Hallon::Search.radio(1990..2010, :jazz, :punk) }
+    end
 
-      mock_session do
-        search = Hallon::Search.radio(1990..2010, :jazz, :punk)
-      end
+    it "should raise an error on invalid genres" do
+      Spotify.should_not_receive(:radio_search_create)
+      expect { Hallon::Search.radio(1990..2010, :bogus, :jazz) }.to raise_error(ArgumentError, /bogus/)
     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
+    it "should raise an error if the search failed" do
+      Spotify.should_receive(:radio_search_create).and_return(null_pointer)
+      expect { mock_session { Hallon::Search.radio(1990..1990) } }.to raise_error(/search failed/)
     end
 
     it { should be_loaded }
-    its(:error) { should eq :ok }
+    its(:status) { 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(:status) { should eq :ok }
   its(:query) { should eq "my query" }
   its(:did_you_mean) { should eq "another thing" }
 

data/spec/hallon/session_spec.rb

@@ -16,6 +16,10 @@ describe Hallon::Session do
         Hallon.initialize
       }.to raise_error
     end
+
+    it "should succeed if everything is right" do
+      expect { Hallon::Session.initialize('appkey_good') }.to_not raise_error
+    end
   end
 
   describe ".new" do
@@ -47,6 +51,18 @@ describe Hallon::Session do
     its([:cache_playlist_metadata]) { should == true }
   end
 
+  describe "#container" do
+    it "should return the sessions’ playlist container" do
+      session.login 'burgestrand', 'pass'
+      session.container.should be_a Hallon::PlaylistContainer
+      session.container.owner.should eq session.user
+    end
+
+    it "should return nil if not logged in" do
+      session.container.should be_nil
+    end
+  end
+
   describe "#process_events" do
     it "should return the timeout" do
       session.process_events.should be_a Fixnum
@@ -64,13 +80,15 @@ describe Hallon::Session do
         else
           session.trigger(:bogus, :bogus)
         end
+
+        0
       end
 
       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 do nothing
+      session.should_receive(:process_events).once.and_return(1) # and do nothing
       session.wait_for(:ever) { |x| x }.should eq :timeout
     end
 
@@ -120,6 +138,17 @@ describe Hallon::Session do
     end
   end
 
+  describe "#user" do
+    it "should return the logged in user" do
+      session.login 'Kim', 'pass'
+      session.user.name.should eq 'Kim'
+    end
+
+    it "should return nil if not logged in" do
+      session.user.should be_nil
+    end
+  end
+
   describe "#country" do
     it "should retrieve the current sessions’ country as a string" do
       session.country.should eq 'SE'
@@ -144,25 +173,6 @@ describe Hallon::Session do
     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
@@ -201,12 +211,12 @@ describe Hallon::Session do
   end
 
   describe "#connection_rules=" do
-    it "should not fail given an invalid rule" do
-      expect { session.connection_rules = :lawly }.to_not raise_error
+    it "should fail given an invalid rule" do
+      expect { session.connection_rules = :lawly }.to 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
+      expect { session.connection_rules = :network, :allow_sync_over_mobile }.to_not raise_error
     end
 
     it "should combine given rules and feed to libspotify" do
@@ -249,15 +259,37 @@ describe Hallon::Session do
     end
   end
 
-  context "when logged in", :logged_in => true do
-    it "should be logged in" do
+
+  describe "#starred" do
+    let(:starred) { mock_session { Hallon::Playlist.new("spotify:user:burgestrand:starred") } }
+
+    it "should return the sessions (current users) starred playlist" do
+      session.login 'burgestrand', 'pass'
+
       session.should be_logged_in
+      session.starred.should eq starred
     end
 
-    describe "#relation_type?" do
-      it "should retrieve the relation between the current user and given user" do
-        session.relation_type?(session.user).should eq :none
-      end
+    it "should return nil if not logged in" do
+      session.should_not be_logged_in
+      session.starred.should be_nil
+    end
+  end
+
+  describe "#inbox" do
+    let(:inbox) { Hallon::Playlist.new(mock_playlist) }
+    let(:session) { mock_session_object }
+
+    it "should return the sessions inbox" do
+      session.login 'burgestrand', 'pass'
+
+      session.should be_logged_in
+      session.inbox.should eq inbox
+    end
+
+    it "should return nil if not logged in" do
+      session.should_not be_logged_in
+      session.inbox.should be_nil
     end
   end
 end