spotify 12.2.0 → 12.3.0

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require 'rbgccxml'
+require 'rspec'
+require 'pry'
+
+require 'spec/support/hook_spotify'
+require 'spec/support/spotify_util'
+
+# 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("../api-#{Spotify.platform}.h", __FILE__)
+API_H_SRC  = File.read(API_H_PATH)
+API_H_XML  = RbGCCXML.parse_xml(API_H_PATH.sub('.h', '.xml'))
+
+RSpec.configure do |config|
+  def api
+    Spotify::API
+  end
+end

data/spec/spotify/api_spec.rb

@@ -0,0 +1,62 @@
+describe "Spotify functions" do
+  API_H_XML.functions.each do |func|
+    next unless func["name"] =~ /\Asp_/
+    attached_name = func["name"].sub(/\Asp_/, '')
+
+    def type_of(type, return_type = false)
+      return case type.to_cpp
+        when "const char*"
+          Spotify::UTF8String
+        when /\A(::)?(char|int|size_t|bool|sp_scrobbling_state|sp_session\*|byte)\*/
+          return_type ? :pointer : :buffer_out
+        when /::(.+_cb)\*/
+          $1.to_sym
+        when /::(\w+)\*\*/
+          :array
+        when /::sp_(\w+)\*/
+          const_name = $1.delete('_')
+          real_const = Spotify.constants.find { |const| const =~ /#{const_name}\z/i }
+          Spotify.const_get(real_const)
+        else
+          :pointer
+      end if type.is_a?(RbGCCXML::PointerType)
+
+      case type["name"]
+      when "unsigned int"
+        :uint
+      else
+        type["name"].sub(/\Asp_/, '').to_sym
+      end
+    end
+
+    # We test several things in this test because if we make the assertions
+    # into separate tests there’s just too much noise on failure.
+    specify(func["name"]) do
+      # it should be attached
+      Spotify.should respond_to attached_name
+
+      # expect the correct number of arguments
+      $attached_methods[attached_name][:args].count.
+        should eq func.arguments.count
+
+      # each argument has the right type
+      current = $attached_methods[attached_name][:args]
+      actual  = func.arguments.map { |arg| type_of(arg.cpp_type) }
+
+      current = current.map { |x| Spotify.resolve_type(x) }
+      actual  = actual.map  { |x| Spotify.resolve_type(x) }
+
+      current.should eq actual
+
+      # returns the correct type
+      current_type = $attached_methods[attached_name][:returns]
+      actual_type  = type_of(func.return_type, true)
+
+      # loosen restraints on some return types, we don’t have enough info from header file
+      current_type = Spotify.resolve_type(current_type)
+      actual_type  = Spotify.resolve_type(actual_type)
+
+      current_type.should eq actual_type
+    end
+  end
+end

data/spec/spotify/defines_spec.rb

@@ -0,0 +1,22 @@
+describe "Spotify enums" do
+  API_H_XML.enumerations.each do |enum|
+    attached_enum = Spotify.enum_type enum["name"].sub(/\Asp_/, '').to_sym
+    original_enum = enum.values.map { |v| [v["name"].downcase, v["init"]] }
+
+    describe enum["name"] do
+      it "should exist" do
+        attached_enum.should_not be_nil
+      end
+
+      it "should match the definition" do
+        attached_enum_map = attached_enum.symbol_map.dup
+        original_enum.each do |(name, value)|
+          a_name, a_value = attached_enum_map.max_by { |(n, v)| (n.to_s.length if name.match(n.to_s)).to_i }
+          attached_enum_map.delete(a_name)
+          a_value.to_s.should eq value
+        end
+      end
+    end
+  end
+end
+

data/spec/spotify/enums_spec.rb

@@ -0,0 +1,9 @@
+describe "Spotify enums" do
+  describe "audio sample types" do
+    Spotify.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
+end

data/spec/spotify/managed_pointer_spec.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+describe Spotify::ManagedPointer do
+  it "is equal to it’s retaining class" do
+    Spotify::User.should eq Spotify::User.retaining_class
+    Spotify::User.retaining_class.should eq Spotify::User
+  end
+
+  it "adds a ref if it is a retaining class" do
+    api.should_receive(:user_add_ref)
+    ptr = Spotify::User.retaining_class.new(FFI::Pointer.new(1))
+    ptr.autorelease = false # avoid auto-GC after test
+  end
+
+  it "does not add or release when the pointer is null" do
+    api.should_not_receive(:user_add_ref)
+    api.should_not_receive(:user_release)
+
+    ptr = Spotify::User.retaining_class.new(FFI::Pointer::NULL)
+    ptr.free
+  end
+
+  describe "garbage collection" do
+    module Spotify
+      class << API
+        def bogus_add_ref(pointer)
+        end
+
+        def bogus_release(pointer)
+        end
+      end
+
+      class Bogus < ManagedPointer
+      end
+    end
+
+    let(:my_pointer) { FFI::Pointer.new(1) }
+
+    it "should work" do
+      api.stub(:bogus_add_ref)
+
+      # GC tests are a bit funky, but as long as we garbage_release at least once, then
+      # we can assume our GC works properly, but up the stakes just for the sake of it
+      api.should_receive(:bogus_release).at_least(1).times
+
+      5.times { Spotify::Bogus.retaining_class.new(FFI::Pointer.new(1)) }
+      5.times { GC.start; sleep 0.01 }
+    end
+  end
+
+  describe "all managed pointers" do
+    Spotify.constants.each do |const|
+      klass = Spotify.const_get(const)
+      next unless klass.is_a?(Class)
+      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
+
+        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
+
+        klass.release(FFI::Pointer.new(1))
+      end
+    end
+  end
+end

data/spec/spotify/spotify_spec.rb

@@ -0,0 +1,69 @@
+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
+  end
+
+  describe ".try" do
+    it "raises an error when the result is not OK" do
+      api.should_receive(:error_example).and_return(:bad_application_key)
+      expect { Spotify.try(:error_example) }.to raise_error(Spotify::Error, /BAD_APPLICATION_KEY/)
+    end
+
+    it "does not raise an error when the result is OK" do
+      api.should_receive(:error_example).and_return(:ok)
+      Spotify.try(:error_example).should eq :ok
+    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
+  end
+
+  describe ".enum_value!" do
+    it "raises an error if given an invalid enum value" do
+      expect { Spotify.enum_value!(:moo, "error value") }.to raise_error(ArgumentError)
+    end
+
+    it "gives back the enum value for that enum" do
+      Spotify.enum_value!(:ok, "error value").should eq 0
+    end
+  end
+
+  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
+        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/structs/session_config_spec.rb

@@ -0,0 +1,20 @@
+describe Spotify::SessionConfig do
+  let(:config) { Spotify::SessionConfig.new }
+
+  it "allows SessionCallbacks as a member value (by reference)" do
+    config[:callbacks] = Spotify::SessionCallbacks.new
+    config[:callbacks].should be_a Spotify::SessionCallbacks
+  end
+
+  it "automatically sets application key size when setting application key from string" do
+    config[:application_key] = "h\x00e\x00y"
+
+    config[:application_key_size].should eq 5
+    config[:application_key].read_string(5).should eq "h\x00e\x00y"
+  end
+
+  it "does not automatically set application key size when setting application key from pointer" do
+    expect { config[:application_key] = FFI::MemoryPointer.from_string("yay") }
+      .to_not change { config[:application_key_size] }
+  end
+end

data/spec/spotify/structs/struct_spec.rb

@@ -0,0 +1,34 @@
+describe Spotify::Struct do
+  let(:klass) do
+    Class.new(Spotify::Struct) do
+      layout :api_version => :int,
+             :cache_location => Spotify::NULString,
+             :user_agent => Spotify::NULString,
+             :compress_playlists => :bool
+    end
+  end
+
+  let(:options) do
+    {
+      :api_version => 1,
+      :cache_location => "Yay",
+      :user_agent => nil,
+      :compress_playlists => false
+    }
+  end
+
+  it "allows initializing the struct with a hash" do
+    struct = klass.new(options)
+    options.each_pair { |key, value| struct[key].should eq value }
+  end
+
+  it "allows initializing the struct with a pointer" do
+    original = klass.new(options)
+    struct = klass.new(original.pointer)
+    options.each_pair { |key, value| struct[key].should eq value }
+  end
+
+  it "allows initializing the struct with nothing" do
+    expect { klass.new }.to_not raise_error
+  end
+end

data/spec/spotify/structs/subscribers_spec.rb

@@ -0,0 +1,31 @@
+describe Spotify::Subscribers do
+  it "should create the subscribers array using count" do
+    # Memory looks like this:
+    #
+    # 00 00 00 00 <- count of subscribers
+    # 00 00 00 00 <- pointer to subscriber 1
+    # …… …… …… ……
+    # 00 00 00 00 <- pointer to subscriber n
+    real_struct = Spotify::Subscribers.new(2)
+    real_struct[:count] = 2
+    real_struct[:subscribers][0] = FFI::MemoryPointer.from_string("a")
+    real_struct[:subscribers][1] = FFI::MemoryPointer.from_string("bb")
+
+    struct = Spotify::Subscribers.new(real_struct.pointer)
+    struct[:count].should eq 2
+    struct[:subscribers].size.should eq 2
+    struct[:subscribers][0].read_string.should eq "a"
+    struct[:subscribers][1].read_string.should eq "bb"
+    expect { struct[:subscribers][2] }.to raise_error(IndexError)
+  end
+
+
+  it "should not fail given an empty subscribers struct" do
+    subscribers = FFI::MemoryPointer.new(:uint)
+    subscribers.write_uint(0)
+
+    subject = Spotify::Subscribers.new(subscribers)
+    subject[:count].should eq 0
+    expect { subject[:subscribers] }.to raise_error(ArgumentError)
+  end
+end

data/spec/spotify/structs_spec.rb

@@ -0,0 +1,19 @@
+describe "Spotify structs" do
+  API_H_XML.structs.each do |struct|
+    next if struct["incomplete"]
+
+    attached_struct = Spotify.structs.find do |const|
+      struct["name"].delete('_').match(/#{const}/i)
+    end
+
+    attached_members = Spotify.const_get(attached_struct).members.map(&:to_s)
+
+    describe struct["name"] do
+      it "should contain the same attributes in the same order" do
+        struct.variables.map(&:name).each_with_index do |member, index|
+          attached_members[index].should eq member
+        end
+      end
+    end
+  end
+end

data/spec/spotify/types/image_id_spec.rb

@@ -0,0 +1,44 @@
+describe Spotify::ImageID do
+  let(:context) { nil }
+  let(:subject) { Spotify::API.find_type(Spotify::ImageID) }
+  let(:null_pointer) { FFI::Pointer::NULL }
+
+  let(:image_id_pointer) do
+    pointer = FFI::MemoryPointer.new(:char, 20)
+    pointer.write_string(image_id)
+    pointer
+  end
+
+  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
+  end
+
+  describe "from_native" do
+    it "should be nil given a null pointer" do
+      subject.from_native(null_pointer, context).should be_nil
+    end
+
+    it "should be an image id given a non-null pointer" do
+      subject.from_native(image_id_pointer, context).should eq image_id
+    end
+  end
+
+  describe "to_native" do
+    it "should be a null pointer given nil" do
+      subject.to_native(nil, context).should be_nil
+    end
+
+    it "should be a 20-byte C string given an actual string" do
+      pointer = subject.to_native(image_id, context)
+      pointer.read_string(20).should eq image_id_pointer.read_string(20)
+    end
+
+    it "should raise an error given more or less than a 20 byte string" do
+      expect { subject.to_native(image_id + image_id, context) }.to raise_error(ArgumentError)
+      expect { subject.to_native(image_id[0..10], context) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/spotify/types/nul_string_spec.rb

@@ -0,0 +1,31 @@
+describe Spotify::NULString do
+  describe ".to_native" do
+    it "returns a memory pointer containing the given string" do
+      pointer = Spotify::NULString.to_native("coolio", nil)
+      pointer.read_string.should eq "coolio"
+    end
+
+    it "returns a null pointer when given nil" do
+      pointer = Spotify::NULString.to_native(nil, nil)
+      pointer.should be_null
+    end
+
+    it "raises an error when given a non-string" do
+      expect { Spotify::NULString.to_native({}, nil) }
+        .to raise_error(TypeError)
+    end
+  end
+
+  describe ".from_native" do
+    it "returns an empty string if given a null pointer" do
+      value = Spotify::NULString.from_native(FFI::Pointer::NULL, nil)
+      value.should be_nil
+    end
+
+    it "returns the string value of the string pointer" do
+      pointer = FFI::MemoryPointer.from_string("hey")
+      value = Spotify::NULString.from_native(pointer, nil)
+      value.should eq "hey"
+    end
+  end
+end