spotify 12.5.3 → 12.6.0

data/spec/spotify/api/track_spec.rb

@@ -0,0 +1,29 @@
+describe "Spotify::API" do
+  describe "#track_set_starred" 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 "changes the starred state of the given tracks" do
+      api.should_receive(:sp_track_set_starred) do |ptr, buffer, buffer_size, starred|
+        ptr.should eq(session)
+        buffer.read_array_of_pointer(buffer_size).should eq(tracks)
+        starred.should eq(true)
+        :ok
+      end
+
+      api.track_set_starred(session, tracks, true).should eq(:ok)
+    end
+
+    it "automatically casts the second parameter to an array" do
+      api.should_receive(:sp_track_set_starred) do |ptr, buffer, buffer_size, starred|
+        buffer.read_array_of_pointer(1).should eq([track_a])
+        buffer_size.should eq(1)
+        :ok
+      end
+
+      api.track_set_starred(session, track_a, true).should eq(:ok)
+    end
+  end
+end

data/spec/spotify/api_error_spec.rb

@@ -0,0 +1,55 @@
+describe Spotify::APIError do
+  let(:context) { nil }
+
+  describe ".from_native" do
+    it "returns an error of the correct class" do
+      error = Spotify::APIError.from_native(15, context)
+      error.should be_a Spotify::UserNeedsPremiumError
+    end
+
+    it "returns nil if not an error" do
+      Spotify::APIError.from_native(0, context).should be_nil
+    end
+
+    it "raises an error if not a valid error code" do
+      expect { Spotify::APIError.from_native(1337, context) }
+        .to raise_error(ArgumentError, /unknown error code/)
+    end
+  end
+
+  describe ".to_i" do
+    it "returns the error code" do
+      Spotify::APIError.to_i.should be_nil
+      Spotify::UserNeedsPremiumError.to_i.should eq(15)
+    end
+  end
+
+  describe "#message" do
+    it "is a formatted message with an explanation of the error" do
+      error = Spotify::UserNeedsPremiumError.new
+      error.message.should match /Needs a premium account/
+      error.message.should match /15/
+    end
+
+    it "can be overridden if necessary" do
+      error = Spotify::UserNeedsPremiumError.new("hoola hoop")
+      error.message.should eq "hoola hoop"
+    end
+  end
+
+  describe "API mapping" do
+    sp_error = API_H_XML.enumerations.each { |enum| break enum if enum.name == "sp_error" }
+    sp_error.values.each do |value|
+      next if value.name =~ /sp_error_ok/i
+      class_name = value.name.downcase.sub(/^sp_error/, "").gsub(/(_|^)(\w)/) { $2.upcase }
+      class_name << "Error" unless class_name =~ /Error/
+
+      describe class_name do
+        it "should have the error code number" do
+          constant = Spotify.constants.grep(/#{class_name}/i)[0]
+          Spotify.const_get(constant).to_i.should eq(value["init"].to_i)
+        end
+      end
+    end
+  end
+end

data/spec/spotify/api_spec.rb

@@ -1,18 +1,24 @@
 describe Spotify::API do
-  describe ".platform" do
-    it "prints a warning containing the OS if platform unknown" do
-      old_platform = FFI::Platform::OS.dup
-      $stderr, old_stderr = StringIO.new, $stderr
+  describe ".attach_function" do
+    it "is a retaining class if the method is not creating" do
+      begin
+        Spotify::API.attach_function :whatever, [], Spotify::User
+      rescue FFI::NotFoundError
+        # expected, this method does not exist
+      end
 
+      $attached_methods["whatever"][:returns].should eq Spotify::User.retaining_class
+    end
+
+    it "is a non-retaining class if the method is creating" do
       begin
-        FFI::Platform::OS.replace "LAWL"
-        Spotify.platform
-        $stderr.rewind
-        $stderr.read.should include "LAWL"
-      ensure
-        $stderr = old_stderr
-        FFI::Platform::OS.replace(old_platform)
+        Spotify::API.attach_function :whatever_create, [], Spotify::User
+      rescue FFI::NotFoundError
+        # expected, this method does not exist
       end
+
+      $attached_methods["whatever_create"][:returns].should be Spotify::User
+      $attached_methods["whatever_create"][:returns].should_not be Spotify::User.retaining_class
     end
   end
 end

data/spec/spotify/{types → data_converters}/best_effort_string_spec.rb

@@ -4,19 +4,19 @@ describe Spotify::BestEffortString do
     it "simply reads a null-terminated string" do
       source = "hello wörld"
       string = Spotify::BestEffortString.to_native(source, nil)
-      string.should eq "hello wörld".force_encoding("BINARY")
+      string.should eq "hello wörld".force_encoding(Encoding::BINARY)
     end
 
     it "cuts the string at the first encountered NULL-byte" do
-      source = "hello\x00wörld".force_encoding("BINARY")
+      source = "hello\x00wörld".force_encoding(Encoding::BINARY)
       string = Spotify::BestEffortString.to_native(source, nil)
-      string.should eq "hello".force_encoding("BINARY")
+      string.should eq "hello".force_encoding(Encoding::BINARY)
     end
 
     it "treats empty string as empty string, and not null" do
       source = ""
       string = Spotify::BestEffortString.to_native(source, nil)
-      string.should eq "".force_encoding("BINARY")
+      string.should eq "".force_encoding(Encoding::BINARY)
     end
   end
 end

data/spec/spotify/data_converters/country_code_spec.rb

@@ -0,0 +1,16 @@
+describe Spotify::CountryCode do
+  let(:context) { nil }
+  subject(:type) { Spotify::API.find_type(Spotify::CountryCode) }
+
+  describe ".from_native" do
+    it "decodes a country code" do
+      type.from_native(21317, context).should eq "SE"
+    end
+  end
+
+  describe ".to_native" do
+    it "encodes a country code" do
+      type.to_native("SE", context).should eq 21317
+    end
+  end
+end

data/spec/spotify/{types → data_converters}/image_id_spec.rb

@@ -12,7 +12,7 @@ describe Spotify::ImageID do
   let(:image_id) do
     # deliberate NULL in middle of string
     image_id = ":\xD94#\xAD\xD9\x97f\xE0\x00V6\x05\xC6\xE7n\xD2\xB0\xE4P"
-    image_id.force_encoding("BINARY")
+    image_id.force_encoding(Encoding::BINARY)
     image_id
   end
 

data/spec/spotify/{types → data_converters}/utf8_string_spec.rb

@@ -9,7 +9,7 @@ describe Spotify::UTF8String do
 
   let(:char) do
     char = "\xC4"
-    char.force_encoding('ISO-8859-1')
+    char.force_encoding(Encoding::ISO_8859_1)
     char
   end
 

data/spec/spotify/{api/functions_spec.rb → functions_spec.rb}

@@ -20,6 +20,8 @@ describe "Spotify functions" do
     case type["name"]
     when "unsigned int"
       :uint
+    when "sp_error"
+      Spotify::APIError
     else
       type["name"].sub(/\Asp_/, '').to_sym
     end

data/spec/spotify/managed_pointer_spec.rb

@@ -1,6 +1,5 @@
 # coding: utf-8
 describe Spotify::ManagedPointer do
-  let(:klass) { described_class }
   let(:null) { FFI::Pointer::NULL }
   let(:pointer) { FFI::Pointer.new(1) }
   let(:klass) { Spotify::User }
@@ -17,19 +16,17 @@ describe Spotify::ManagedPointer do
     api.should_not_receive(:user_release)
 
     ptr = retaining_klass.new(FFI::Pointer::NULL)
-    ptr.autorelease = false
     ptr.free
   end
 
   describe "#release" do
     it "wraps the release pointer properly to avoid type-failures" do
-      api.should_receive(:user_release).and_return do |pointer|
+      api.should_receive(:user_release) do |pointer|
         pointer.should be_instance_of(klass)
         pointer.should_not be_autorelease # autorelease should be off
       end
 
       ptr = klass.new(FFI::Pointer.new(1))
-      ptr.autorelease = false
       ptr.free
     end
   end
@@ -61,6 +58,13 @@ describe Spotify::ManagedPointer do
     end
   end
 
+  describe ".from_native" do
+    it "returns nil if pointer is null" do
+      native = FFI::Pointer::NULL
+      klass.from_native(native, nil).should be_nil
+    end
+  end
+
   describe ".size" do
     it "returns the size of a pointer" do
       Spotify::ManagedPointer.size.should eq FFI.type_size(:pointer)
@@ -106,21 +110,17 @@ describe Spotify::ManagedPointer do
       next unless klass < Spotify::ManagedPointer
 
       it "#{klass.name} has a valid retain method" do
-        Spotify.should_receive(:public_send).and_return do |method, *args|
-          Spotify.should respond_to(method)
-          method.should match(/_add_ref$/)
-        end
+        Spotify.should_receive(:"#{klass.type}_add_ref")
+        Spotify.should respond_to(:"#{klass.type}_add_ref")
 
         klass.retain(FFI::Pointer.new(1))
       end unless klass == Spotify::Session # has no valid retain
 
       it "#{klass.name} has a valid release method" do
-        Spotify.should_receive(:public_send).and_return do |method, *args|
-          Spotify.should respond_to(method)
-          method.should match(/_release$/)
-        end
+        Spotify.should_receive(:"#{klass.type}_release")
+        Spotify.should respond_to(:"#{klass.type}_release")
 
-        klass.release(FFI::Pointer.new(1))
+        klass.release(FFI::Pointer.new(1)).value
       end
     end
   end

data/spec/spotify/structs/subscribers_spec.rb

@@ -100,10 +100,12 @@ describe Spotify::Subscribers do
       end
     end
 
+    it "returns an enumerator when not given a block" do
+      subscribers.each.should be_a Enumerator
+    end
+
     it "returns an enumerator with a defined size when not given a block", :ruby_version => ">= 2.0.0" do
-      enumerator = subscribers.each
-      enumerator.should be_a Enumerator
-      enumerator.size.should eq 3
+      subscribers.each.size.should eq 3
     end
 
     it "yields every subscriber as an UTF-8 encoded string" do

data/spec/spotify/{defines_spec.rb → types_spec.rb}

@@ -1,6 +1,20 @@
-describe "Spotify enums" do
+describe "Spotify types" do
+  describe "audio sample types" do
+    Spotify::API.enum_type(:sampletype).symbols.each do |symbol|
+      specify "#{symbol} has a reader in FFI" do
+        FFI::Pointer.new(1).should respond_to "read_array_of_#{symbol}"
+      end
+    end
+  end
+
   API_H_XML.enumerations.each do |enum|
-    attached_enum = Spotify.enum_type enum["name"].sub(/\Asp_/, '').to_sym
+    next if enum["name"] == "sp_error"
+
+    attached_tag = enum["name"].sub(/\Asp_/, '').to_sym
+    attached_enum = Spotify.enum_type(attached_tag)
+    unless attached_enum.tag == attached_tag
+      raise "Cannot find attached enum for #{enum["name"]}"
+    end
     original_enum = enum.values.map { |v| [v["name"].downcase, v["init"]] }
 
     describe enum["name"] do
@@ -19,4 +33,3 @@ describe "Spotify enums" do
     end
   end
 end
-

data/spec/spotify/util_spec.rb

@@ -0,0 +1,24 @@
+describe "Spotify::Util" do
+  describe ".enum_value!" do
+    it "raises an error if given an invalid enum value" do
+      expect { Spotify::Util.enum_value!(:moo, "error value") }.to raise_error(ArgumentError)
+    end
+
+    it "gives back the enum value for that enum" do
+      Spotify::Util.enum_value!(:no_tracks, "search browse").should eq 1
+    end
+  end
+
+  describe ".platform" do
+    it "prints a warning containing the OS if platform unknown" do
+      suppress = true
+      _, err = spy_output(suppress) do
+        stub_const("FFI::Platform::OS", "LAWL")
+        Spotify::Util.platform
+      end
+
+      err.should match "unknown platform"
+      err.should match "LAWL"
+    end
+  end
+end

data/spec/spotify_spec.rb

@@ -0,0 +1,74 @@
+describe Spotify do
+  describe "VERSION" do
+    it "is defined" do
+      defined?(Spotify::VERSION).should eq "constant"
+    end
+
+    it "is the same version as in api.h" do
+      spotify_version = API_H_SRC.match(/#define\s+SPOTIFY_API_VERSION\s+(\d+)/)[1]
+      Spotify::API_VERSION.to_i.should eq spotify_version.to_i
+    end
+  end
+
+  describe "proxying" do
+    it "responds to the spotify methods" do
+      Spotify.should respond_to :error_message
+    end
+
+    it "allows creating proxy methods" do
+      api.should_receive(:error_message).and_return("Some error")
+      Spotify.method(:error_message).call.should eq "Some error"
+    end
+  end
+
+  describe ".log" do
+    it "print nothing if not debugging" do
+      out, err = spy_output do
+        old_debug, $DEBUG = $DEBUG, false
+        Spotify.log "They see me loggin'"
+        $DEBUG = old_debug
+      end
+      out.should be_empty
+      err.should be_empty
+    end
+
+    it "prints output and path if debugging" do
+      suppress = true
+      out, err = spy_output(suppress) do
+        old_debug, $DEBUG = $DEBUG, true
+        Spotify.log "Testin' Spotify log"
+        $DEBUG = old_debug
+      end
+
+      out.should match "Testin' Spotify log"
+      out.should match "spec/spotify_spec.rb"
+
+      err.should be_empty
+    end
+  end
+
+  describe ".try" do
+    it "raises an error when the result is not OK" do
+      api.should_receive(:error_example).and_return(Spotify::APIError.from_native(5, nil))
+      expect { Spotify.try(:error_example) }.to raise_error(Spotify::BadApplicationKeyError, /Invalid application key/)
+    end
+
+    it "does not raise an error when the result is OK" do
+      api.should_receive(:error_example).and_return(nil)
+      Spotify.try(:error_example).should eq nil
+    end
+
+    it "does not raise an error when the result is not an error-type" do
+      result = Object.new
+      api.should_receive(:error_example).and_return(result)
+      Spotify.try(:error_example).should eq result
+    end
+
+    it "does not raise an error when the resource is loading" do
+      api.should_receive(:error_example).and_return(Spotify::APIError.from_native(17, nil))
+      error = Spotify.try(:error_example)
+      error.should be_a(Spotify::IsLoadingError)
+      error.message.should match /Resource not loaded yet/
+    end
+  end
+end

data/spec/support/spotify_util.rb

@@ -1,15 +1,19 @@
 module Spotify
   # used to find the actual type of a thing
   def self.resolve_type(type)
-    if type.is_a?(Class) and type <= Spotify::ManagedPointer
+    found = if type.is_a?(Class) and type <= Spotify::ManagedPointer
+      type
+    elsif type == Spotify::APIError
       type
     elsif type.respond_to?(:native_type)
       type.native_type
     else
       type = Spotify::API.find_type(type)
-      type = type.type if type.respond_to?(:type)
       type
     end
+
+    found = found.type while found.respond_to?(:type)
+    found
   end
 
   # @return [Array<FFI::Struct>] all structs in Spotify namespace

data/spec/support/spy_output.rb

@@ -0,0 +1,16 @@
+require "stringio"
+
+def spy_output(suppress = false)
+  old_out, $stdout = $stdout, StringIO.new
+  old_err, $stderr = $stderr, StringIO.new
+  yield
+  out = $stdout.tap(&:rewind).read
+  err = $stderr.tap(&:rewind).read
+  [out, err]
+ensure
+  old_out.write(out) if not suppress and out
+  old_err.write(err) if not suppress and err
+
+  $stderr = old_err
+  $stdout = old_out
+end