spotify 12.5.3 → 12.6.0

data/lib/spotify/version.rb

@@ -1,7 +1,7 @@
 module Spotify
   # @note See README for versioning policy.
   # @return [String] Spotify gem version.
-  VERSION = '12.5.3'
+  VERSION = '12.6.0'
 
   # @return [String] Compatible libspotify API version.
   API_VERSION = '12.1.51'

data/spec/spec_helper.rb

@@ -1,24 +1,36 @@
 # encoding: utf-8
 require "rbgccxml"
 require "rspec"
-require "pry"
 require "stringio"
 
 require "spec/support/hook_spotify"
 require "spec/support/spotify_util"
+require "spec/support/spy_output"
 
 # You can pregenerate new XML files through:
 # gccxml spec/api-mac.h -fxml=spec/api-mac.xml
 # gccxml spec/api-linux.h -fxml=spec/api-linux.xml
-API_H_PATH = File.expand_path("../support/api-#{Spotify.platform}.h", __FILE__)
+API_H_PATH = File.expand_path("../support/api-#{Spotify::Util.platform}.h", __FILE__)
 API_H_SRC  = File.read(API_H_PATH)
 API_H_XML  = RbGCCXML.parse_xml(API_H_PATH.sub('.h', '.xml'))
 
+class << Spotify
+  attr_accessor :performer
+end
+
 RSpec.configure do |config|
   def api
     Spotify::API
   end
 
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
   config.filter_run_excluding(engine: ->(engine) do
     ! Array(engine).include?(RUBY_ENGINE)
   end)
@@ -30,17 +42,16 @@ RSpec.configure do |config|
   end)
 
   config.around(:each) do |test|
-    stderr, $stderr = $stderr, StringIO.new("")
-    begin
-      test.run
-      $stderr.rewind
-      warnings = $stderr.read
-      if warnings =~ %r"lib/spotify"
-        stderr.write(warnings)
-        raise "#{example.description.inspect} caused a warning, #{warnings.inspect}"
-      end
-    ensure
-      $stderr = stderr
+    _, warnings = spy_output { test.run }
+    if warnings =~ %r"lib/spotify" and not $DEBUG
+      raise "#{example.description.inspect} caused a warning, #{warnings.inspect}"
     end
   end
+
+  config.around(:each) do |example|
+    Spotify.performer = Performer.new
+    example.run
+    task = Spotify.performer.shutdown
+    task.value # wait for shutdown
+  end
 end

data/spec/spotify/api/image_spec.rb

@@ -0,0 +1,32 @@
+describe "Spotify::API" do
+  describe "#image_data" do
+    let(:image) { double }
+
+    it "reads the raw image data" do
+      api.should_receive(:sp_image_data) do |img, img_size_pointer|
+        img.should eq(image)
+        img_size_pointer.write_size_t(8)
+        FFI::MemoryPointer.from_string("image data")
+      end
+
+      api.image_data(image).should eq "image da"
+    end
+
+    it "is nil if image data is null" do
+      api.should_receive(:sp_image_data) do |img, img_size_pointer|
+        FFI::Pointer::NULL
+      end
+
+      api.image_data(image).should be_nil
+    end
+
+    it "is nil if image data size is 0" do
+      api.should_receive(:sp_image_data) do |img, img_size_pointer|
+        img_size_pointer.write_size_t(0)
+        FFI::MemoryPointer.from_string("image data")
+      end
+
+      api.image_data(image).should be_nil
+    end
+  end
+end

data/spec/spotify/api/inbox_spec.rb

@@ -0,0 +1,34 @@
+describe "Spotify::API" do
+  describe "#inbox_post_tracks" do
+    let(:session) { double }
+    let(:callback) { lambda {} }
+    let(:track_a) { FFI::MemoryPointer.new(:pointer) }
+    let(:track_b) { FFI::MemoryPointer.new(:pointer) }
+    let(:tracks) { [track_a, track_b] }
+    let(:inbox) { double }
+
+    it "posts an array of tracks to a user's inbox" do
+      api.should_receive(:sp_inbox_post_tracks) do |ptr, username, buffer, buffer_size, message, ptr_callback, userdata|
+        ptr.should eq(session)
+        username.should eq("burgestrand")
+        buffer.read_array_of_pointer(buffer_size).should eq(tracks)
+        message.should eq("You must listen to these!")
+        ptr_callback.should eq(callback)
+        userdata.should eq(:userdata)
+        inbox
+      end
+
+      api.inbox_post_tracks(session, "burgestrand", tracks, "You must listen to these!", callback, :userdata).should eq(inbox)
+    end
+
+    it "casts a single track to an array" do
+      api.should_receive(:sp_inbox_post_tracks) do |ptr, username, buffer, buffer_size, message, ptr_callback, userdata|
+        buffer.read_array_of_pointer(1).should eq([track_a])
+        buffer_size.should eq(1)
+        inbox
+      end
+
+      api.inbox_post_tracks(session, "burgestrand", track_a, "You must listen to these!", callback, :userdata).should eq(inbox)
+    end
+  end
+end

data/spec/spotify/api/link_spec.rb

@@ -0,0 +1,40 @@
+describe "Spotify::API" do
+  describe "#link_as_string" do
+    let(:link) { double }
+
+    it "reads the link as an UTF-8 encoded string" do
+      api.should_receive(:sp_link_as_string).twice do |ptr, buffer, buffer_size|
+        ptr.should eq(link)
+        buffer.write_bytes("spotify:user:burgestrandX") if buffer
+        24
+      end
+
+      string = api.link_as_string(link)
+      string.should eq "spotify:user:burgestrand"
+      string.encoding.should eq(Encoding::UTF_8)
+    end
+  end
+
+  describe "#link_as_track_and_offset" do
+    let(:link) { double }
+    let(:track) { double }
+
+    it "reads the link as a track with offset information" do
+      api.should_receive(:sp_link_as_track_and_offset) do |ptr, offset_pointer|
+        ptr.should eq(link)
+        offset_pointer.write_int(6000)
+        track
+      end
+
+      api.link_as_track_and_offset(link).should eq([track, 6000])
+    end
+
+    it "returns nil if the link is not a track link" do
+      api.should_receive(:sp_link_as_track_and_offset) do |ptr, offset_pointer|
+        nil
+      end
+
+      api.link_as_track_and_offset(link).should be_nil
+    end
+  end
+end

data/spec/spotify/api/playlist_spec.rb

@@ -0,0 +1,99 @@
+describe "Spotify::API" do
+  let(:playlist) { double }
+
+  describe "#playlist_get_image" do
+    let(:image_id) { "v\xE5\xAA\xD3F\xF8\xEE4G\xA1.D\x9C\x85 \xC5\xFD\x80]\x99".force_encoding(Encoding::BINARY) }
+
+    it "returns the image ID if playlist has an image" do
+      api.should_receive(:sp_playlist_get_image) do |ptr, image_id_pointer|
+        ptr.should eq(playlist)
+        image_id_pointer.write_bytes(image_id)
+        true
+      end
+
+      api.playlist_get_image(playlist).should eq(image_id)
+    end
+
+    it "returns nil if playlist has no image" do
+      api.should_receive(:sp_playlist_get_image) do |ptr, image_id_pointer|
+        false
+      end
+
+      api.playlist_get_image(playlist).should be_nil
+    end
+  end
+
+  describe "#playlist_add_tracks" do
+    let(:session) { double }
+    let(:track_a) { FFI::MemoryPointer.new(:pointer) }
+    let(:track_b) { FFI::MemoryPointer.new(:pointer) }
+    let(:tracks) { [track_a, track_b] }
+
+    it "adds an array of tracks to a playlist" do
+      api.should_receive(:sp_playlist_add_tracks) do |ptr, buffer, buffer_size, offset, ptr_session|
+        ptr.should eq(playlist)
+        buffer.read_array_of_pointer(buffer_size).should eq(tracks)
+        offset.should eq(2)
+        ptr_session.should eq(session)
+        :ok
+      end
+
+      api.playlist_add_tracks(playlist, tracks, 2, session).should eq(:ok)
+    end
+
+    it "casts a single track to an array" do
+      api.should_receive(:sp_playlist_add_tracks) do |ptr, buffer, buffer_size, offset, ptr_session|
+        buffer.read_array_of_pointer(1).should eq([track_a])
+        buffer_size.should eq(1)
+        :ok
+      end
+
+      api.playlist_add_tracks(playlist, track_a, 2, session).should eq(:ok)
+    end
+  end
+
+  describe "#playlist_remove_tracks" do
+    it "removes tracks from a playlist" do
+      api.should_receive(:sp_playlist_remove_tracks) do |ptr, buffer, buffer_size|
+        ptr.should eq(playlist)
+        buffer.read_array_of_int(buffer_size).should eq([1, 3, 7])
+        :ok
+      end
+
+      api.playlist_remove_tracks(playlist, [1, 3, 7]).should eq(:ok)
+    end
+
+    it "casts a single index to an array" do
+      api.should_receive(:sp_playlist_remove_tracks) do |ptr, buffer, buffer_size|
+        buffer.read_array_of_int(1).should eq([3])
+        buffer_size.should eq(1)
+        :ok
+      end
+
+      api.playlist_remove_tracks(playlist, 3).should eq(:ok)
+    end
+  end
+
+  describe "#playlist_reorder_tracks" do
+    it "reorders tracks from a playlist" do
+      api.should_receive(:sp_playlist_reorder_tracks) do |ptr, buffer, buffer_size, index|
+        ptr.should eq(playlist)
+        buffer.read_array_of_int(buffer_size).should eq([1, 3, 7])
+        index.should eq(3)
+        :ok
+      end
+
+      api.playlist_reorder_tracks(playlist, [1, 3, 7], 3).should eq(:ok)
+    end
+
+    it "casts a single index to an array" do
+      api.should_receive(:sp_playlist_reorder_tracks) do |ptr, buffer, buffer_size, index|
+        buffer.read_array_of_int(1).should eq([7])
+        buffer_size.should eq(1)
+        :ok
+      end
+
+      api.playlist_reorder_tracks(playlist, 7, 3).should eq(:ok)
+    end
+  end
+end

data/spec/spotify/api/playlistcontainer_spec.rb

@@ -0,0 +1,82 @@
+describe "Spotify::API" do
+  let(:container) { double }
+
+  describe "#playlistcontainer_playlist_folder_name" do
+    let(:index) { 0 }
+
+    it "returns the folder name" do
+      api.should_receive(:sp_playlistcontainer_playlist_folder_name) do |ptr, index, name_pointer, name_pointer_size|
+        ptr.should eq(container)
+        name_pointer.write_bytes("Summer Playlists\x00")
+        :ok
+      end
+
+      folder_name = api.playlistcontainer_playlist_folder_name(container, index)
+      folder_name.should eq "Summer Playlists"
+      folder_name.encoding.should eq(Encoding::UTF_8)
+    end
+
+    it "returns nil if out of range" do
+      api.should_receive(:sp_playlistcontainer_playlist_folder_name) do |ptr, index, name_pointer, name_pointer_size|
+        :error_index_out_of_range
+      end
+
+      api.playlistcontainer_playlist_folder_name(container, index).should be_nil
+    end
+
+    it "returns nil if not a folder" do
+      api.should_receive(:sp_playlistcontainer_playlist_folder_name) do |ptr, index, name_pointer, name_pointer_size|
+        name_pointer.write_bytes("\x00")
+        :ok
+      end
+
+      api.playlistcontainer_playlist_folder_name(container, index).should be_nil
+    end
+  end
+
+  describe "#playlistcontainer_get_unseen_tracks" do
+    def track(id)
+      pointer = FFI::MemoryPointer.new(:int)
+      pointer.write_int(id.to_i)
+      pointer
+    end
+
+    let(:playlist) { double }
+    let(:track_a) { track(1337) }
+    let(:track_b) { track(7331) }
+
+    it "returns an array of unseen tracks" do
+      Spotify::Track.retaining_class.should_receive(:from_native).twice do |pointer, context|
+        pointer.read_int
+      end
+
+      api.should_receive(:sp_playlistcontainer_get_unseen_tracks).twice do |ptr, ptr_playlist, tracks_buffer, tracks_buffer_size|
+        ptr.should eq(container)
+        ptr_playlist.should eq(playlist)
+        if tracks_buffer
+          tracks_buffer.write_array_of_pointer([track_a, track_b])
+          tracks_buffer_size.should eq(2)
+        end
+        2
+      end
+
+      api.playlistcontainer_get_unseen_tracks(container, playlist).should eq([1337, 7331])
+    end
+
+    it "returns an empty array when there are no unseen tracks" do
+      api.should_receive(:sp_playlistcontainer_get_unseen_tracks) do |ptr, playlist, tracks_buffer, tracks_buffer_size|
+        0
+      end
+
+      api.playlistcontainer_get_unseen_tracks(container, playlist).should be_empty
+    end
+
+    it "returns an empty array on failure" do
+      api.should_receive(:sp_playlistcontainer_get_unseen_tracks) do |ptr, playlist, tracks_buffer, tracks_buffer_size|
+        -1
+      end
+
+      api.playlistcontainer_get_unseen_tracks(container, playlist).should be_empty
+    end
+  end
+end

data/spec/spotify/api/session_spec.rb

@@ -0,0 +1,97 @@
+describe "Spotify::API" do
+  let(:session) { double }
+
+  describe "#session_create" do
+    let(:config) do
+      {
+        user_agent: "This is a test",
+        callbacks: Spotify::SessionCallbacks.new(music_delivery: proc {})
+      }
+    end
+
+    let(:session_pointer) { FFI::MemoryPointer.new(:pointer) }
+
+    it "creates a session with the given configuration" do
+      api.should_receive(:sp_session_create) do |struct_config, ptr_session|
+        struct_config.should be_a(Spotify::SessionConfig)
+        struct_config[:user_agent].should eq("This is a test")
+        struct_config[:callbacks].should be_a(Spotify::SessionCallbacks)
+        ptr_session.write_pointer(session_pointer)
+        :ok
+      end
+
+      error, session = api.session_create(config)
+      error.should be_nil
+      session.should be_a(Spotify::Session)
+      session.address.should eq(session_pointer.address)
+    end
+
+    it "returns the error without session on failure" do
+      api.should_receive(:sp_session_create) do |struct_config, ptr_session|
+        :bad_api_version
+      end
+
+      error, session = api.session_create(config)
+      error.should eq(:bad_api_version)
+      session.should be_nil
+    end
+  end
+
+  describe "#session_process_events" do
+    it "returns time until session_process_events should be called again" do
+      api.should_receive(:sp_session_process_events) do |ptr, timeout_pointer|
+        ptr.should eq(session)
+        timeout_pointer.write_int(1337)
+        :ok
+      end
+
+      api.session_process_events(session).should eq(1337)
+    end
+  end
+
+  describe "#session_remembered_user" do
+    it "returns the name of the remembered user" do
+      api.should_receive(:sp_session_remembered_user).twice do |ptr, string_pointer, string_pointer_size|
+        ptr.should eq(session)
+        string_pointer.write_bytes("BurgeX") if string_pointer
+        5
+      end
+
+      api.session_remembered_user(session).should eq("Burge")
+    end
+
+    it "returns nil if there is no remembered user" do
+      api.should_receive(:sp_session_remembered_user) do |ptr, string_pointer, string_pointer_size|
+        -1
+      end
+
+      api.session_remembered_user(session).should be_nil
+    end
+  end
+
+  describe "#session_is_scrobbling" do
+    it "returns the scrobbling state" do
+      api.should_receive(:sp_session_is_scrobbling) do |ptr, social_provider, state_pointer|
+        ptr.should eq(session)
+        social_provider.should eq(:spotify)
+        state_pointer.write_int(3)
+        :ok
+      end
+
+      api.session_is_scrobbling(session, :spotify).should eq(:global_enabled)
+    end
+  end
+
+  describe "#session_is_scrobbling_possible" do
+    it "returns true if scrobbling is possible" do
+      api.should_receive(:sp_session_is_scrobbling_possible) do |ptr, social_provider, buffer_out|
+        ptr.should eq(session)
+        social_provider.should eq(:spotify)
+        buffer_out.write_char(1)
+        :ok
+      end
+
+      api.session_is_scrobbling_possible(session, :spotify).should eq(true)
+    end
+  end
+end