hallon 0.18.0 → 0.18.1

data/spec/hallon/playlist_container_spec.rb

@@ -102,7 +102,7 @@ describe Hallon::PlaylistContainer do
     end
 
     it "should return nil when failing to add the item" do
-      Spotify.should_receive(:playlistcontainer_add_playlist).and_return(null_pointer)
+      spotify_api.should_receive(:playlistcontainer_add_playlist).and_return(null_pointer)
       playlist = container.add Hallon::Link.new("spotify:user:burgestrand")
       playlist.should be_nil
     end
@@ -295,7 +295,7 @@ describe Hallon::PlaylistContainer do
     end
 
     it "raises an error if the result was an error (but count was not)" do
-      Spotify.should_receive(:playlistcontainer_get_unseen_tracks).and_return(4, -1)
+      spotify_api.should_receive(:playlistcontainer_get_unseen_tracks).and_return(4, -1)
       expect { container.unseen_tracks_for(empty_playlist) }.to raise_error(Hallon::OperationFailedError)
     end
   end

data/spec/hallon/playlist_spec.rb

@@ -137,7 +137,7 @@ describe Hallon::Playlist do
 
   describe "#tracks" do
     it "returns an enumerator of the playlist’s tracks" do
-      playlist.tracks.to_a.should eq instantiate(Hallon::Playlist::Track, *(0...4).map { |index| [Spotify.playlist_track!(playlist.pointer, index), playlist.pointer, index] })
+      playlist.tracks.to_a.should eq instantiate(Hallon::Playlist::Track, *(0...4).map { |index| [Spotify.playlist_track(playlist.pointer, index), playlist.pointer, index] })
     end
 
     it "returns an empty enumerator if the playlist has no tracks" do
@@ -231,7 +231,7 @@ describe Hallon::Playlist do
     end
 
     it "should return an empty array when there are no subscribers" do
-      Spotify.should_receive(:playlist_subscribers).and_return(mock_empty_subscribers)
+      spotify_api.should_receive(:playlist_subscribers).and_return(mock_empty_subscribers)
       playlist.subscribers.should eq []
     end
 
@@ -321,9 +321,9 @@ describe Hallon::Playlist do
 
   describe "#autolink_tracks=" do
     it "should set autolink status" do
-      Spotify.mocksp_playlist_get_autolink_tracks(playlist.pointer).should be_false
+      Spotify.mock_playlist_get_autolink_tracks(playlist.pointer).should be_false
       playlist.autolink_tracks = true
-      Spotify.mocksp_playlist_get_autolink_tracks(playlist.pointer).should be_true
+      Spotify.mock_playlist_get_autolink_tracks(playlist.pointer).should be_true
     end
   end
 
@@ -359,22 +359,22 @@ describe Hallon::Playlist do
     end
 
     specify "#available_offline?" do
-      Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(1)
+      spotify_api.should_receive(:playlist_get_offline_status).and_return symbol_for(1)
       playlist.should be_available_offline
     end
 
     specify "#syncing?" do
-      Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(2)
+      spotify_api.should_receive(:playlist_get_offline_status).and_return symbol_for(2)
       playlist.should be_syncing
     end
 
     specify "#waiting?" do
-      Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(3)
+      spotify_api.should_receive(:playlist_get_offline_status).and_return symbol_for(3)
       playlist.should be_waiting
     end
 
     specify "#offline_mode?" do
-      Spotify.should_receive(:playlist_get_offline_status).and_return symbol_for(0)
+      spotify_api.should_receive(:playlist_get_offline_status).and_return symbol_for(0)
       playlist.should_not be_offline_mode
     end
   end

data/spec/hallon/scrobbler_spec.rb

@@ -21,24 +21,24 @@ describe Hallon::Scrobbler do
 
   describe "#credentials=" do
     it "sets the credentials for the scrobbler provider" do
-      Spotify.should_receive(:session_set_social_credentials).with(anything, :facebook, "Kim", "password").and_return(:ok)
+      spotify_api.should_receive(:session_set_social_credentials).with(anything, :facebook, "Kim", "password").and_return(:ok)
       scrobbling.credentials = "Kim", "password"
     end
   end
 
   describe "#possible?" do
     it "returns true if scrobbling is possible" do
-      Spotify.mocksp_session_set_is_scrobbling_possible(session.pointer, scrobbling.provider, true)
+      Spotify.mock_session_set_is_scrobbling_possible(session.pointer, scrobbling.provider, true)
       scrobbling.should be_possible
     end
 
     it "returns false if scrobbling is not possible" do
-      Spotify.mocksp_session_set_is_scrobbling_possible(session.pointer, scrobbling.provider, false)
+      Spotify.mock_session_set_is_scrobbling_possible(session.pointer, scrobbling.provider, false)
       scrobbling.should_not be_possible
     end
 
     it "raises an error if libspotify does not like us" do
-      Spotify.should_receive(:session_is_scrobbling_possible).and_return(:invalid_indata)
+      spotify_api.should_receive(:session_is_scrobbling_possible).and_return(:invalid_indata)
       expect { scrobbling.possible? }.to raise_error(Spotify::Error)
     end
   end
@@ -53,14 +53,14 @@ describe Hallon::Scrobbler do
     end
 
     it "raises an error if setting scrobbling state fails" do
-      Spotify.should_receive(:session_set_scrobbling).and_return(:invalid_indata)
+      spotify_api.should_receive(:session_set_scrobbling).and_return(:invalid_indata)
       expect { scrobbling.enabled = true }.to raise_error(Spotify::Error, /INVALID_INDATA/)
     end
   end
 
   describe "#enabled?" do
     before do
-      Spotify.should_receive(:session_is_scrobbling).and_return do |session, provider, buffer|
+      spotify_api.should_receive(:session_is_scrobbling).and_return do |session, provider, buffer|
         buffer.write_int(Spotify.enum_value(state_symbol))
       end
     end
@@ -103,13 +103,14 @@ describe Hallon::Scrobbler do
       session = scrobbling.send(:session)
       state   = nil
       FFI::Buffer.alloc_out(:int) do |buffer|
-        Spotify.session_is_scrobbling!(session.pointer, scrobbling.provider, buffer)
+        Spotify.try(:session_is_scrobbling, session.pointer, scrobbling.provider, buffer)
         state = buffer.read_int
       end
       Spotify.enum_type(:scrobbling_state)[state]
     end
 
     it "sets the local scrobbling state to use the global state" do
+      state(scrobbling).should eq :use_global_setting
       scrobbling.enabled = true
       state(scrobbling).should eq :local_enabled
       scrobbling.reset

data/spec/hallon/search_spec.rb

@@ -21,12 +21,12 @@ describe Hallon::Search do
 
   describe ".new" do
     it "should have some sane defaults" do
-      Spotify.should_receive(:search_create).with(session.pointer, "my å utf8  query", 0, 25, 0, 25, 0, 25, 0, 25, :standard, anything, anything).and_return(mock_search)
+      spotify_api.should_receive(:search_create).with(session.pointer, "my å utf8  query", 0, 25, 0, 25, 0, 25, 0, 25, :standard, anything, anything).and_return(mock_search)
       Hallon::Search.new("my å utf8  query")
     end
 
     it "should allow you to customize the defaults" do
-      Spotify.should_receive(:search_create).with(session.pointer, "my å utf8  query", 1, 2, 3, 4, 5, 6, 7, 8, :suggest, anything, anything).and_return(mock_search)
+      spotify_api.should_receive(:search_create).with(session.pointer, "my å utf8  query", 1, 2, 3, 4, 5, 6, 7, 8, :suggest, anything, anything).and_return(mock_search)
       my_params = {
         :tracks_offset  => 1,
         :tracks         => 2,
@@ -47,7 +47,7 @@ describe Hallon::Search do
     end
 
     it "should raise an error if the search failed" do
-      Spotify.should_receive(:search_create).and_return(null_pointer)
+      spotify_api.should_receive(:search_create).and_return(null_pointer)
       expect { Hallon::Search.new("omgwtfbbq") }.to raise_error(/search (.*?) failed/)
     end
   end

data/spec/hallon/session_spec.rb

@@ -57,12 +57,12 @@ describe Hallon::Session do
   describe "options" do
     subject { session.options }
     its([:user_agent]) { should == options[:user_agent] }
-    its([:settings_path]) { should == options[:settings_path] }
-    its([:cache_path]) { should == options[:cache_path] }
+    its([:settings_location]) { should == options[:settings_location] }
+    its([:cache_location]) { should == options[:cache_location] }
 
-    its([:load_playlists]) { should == true }
+    its([:initially_unload_playlists]) { should == false }
     its([:compress_playlists]) { should == true }
-    its([:cache_playlist_metadata]) { should == true }
+    its([:dont_save_metadata_for_playlists]) { should == false }
   end
 
   describe "#container" do
@@ -133,12 +133,12 @@ describe Hallon::Session do
     end
 
     it "should login with a blob when given a blob" do
-      Spotify.should_receive(:session_login).with(anything, 'Kim', nil, false, 'blob')
+      spotify_api.should_receive(:session_login).with(anything, 'Kim', nil, false, 'blob')
       session.login 'Kim', Hallon::Blob('blob')
     end
 
     it "should not login with a blob when not given a blob" do
-      Spotify.should_receive(:session_login).with(anything, 'Kim', 'pass', false, nil)
+      spotify_api.should_receive(:session_login).with(anything, 'Kim', 'pass', false, nil)
       session.login 'Kim', 'pass'
     end
   end
@@ -241,7 +241,7 @@ describe Hallon::Session do
     end
 
     it "should combine given rules and feed to libspotify" do
-      Spotify.should_receive(:session_set_connection_rules).with(session.pointer, 5)
+      spotify_api.should_receive(:session_set_connection_rules).with(session.pointer, 5)
       session.connection_rules = :network, :allow_sync_over_mobile
     end
   end
@@ -261,7 +261,7 @@ describe Hallon::Session do
       end
 
       it "returns an empty hash when offline sync status details are unavailable" do
-        Spotify.should_receive(:offline_sync_get_status).and_return(false)
+        spotify_api.should_receive(:offline_sync_get_status).and_return(false)
         session.offline_sync_status.should eq Hash.new
       end
     end
@@ -281,12 +281,12 @@ describe Hallon::Session do
 
   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).and_return(:ok)
+      spotify_api.should_receive(:session_preferred_offline_bitrate).with(session.pointer, :'96k', false).and_return(:ok)
       session.offline_bitrate = :'96k'
     end
 
     it "should resync if asked to" do
-      Spotify.should_receive(:session_preferred_offline_bitrate).with(session.pointer, :'96k', true).and_return(:ok)
+      spotify_api.should_receive(:session_preferred_offline_bitrate).with(session.pointer, :'96k', true).and_return(:ok)
       session.offline_bitrate = :'96k', :resync
     end
 

data/spec/hallon/toplist_spec.rb

@@ -2,12 +2,12 @@
 
 describe Hallon::Toplist do
   let(:toplist) do
-    Spotify.registry_add 'spotify:toplist:artists:everywhere', mock_toplistbrowse
+    Spotify.mock_registry_add 'spotify:toplist:artists:everywhere', mock_toplistbrowse
     Hallon::Toplist.new(:artists)
   end
 
   let(:empty_toplist) do
-    Spotify.registry_add 'spotify:toplist:tracks:everywhere', mock_empty_toplistbrowse
+    Spotify.mock_registry_add 'spotify:toplist:tracks:everywhere', mock_empty_toplistbrowse
     Hallon::Toplist.new(:tracks)
   end
 
@@ -20,12 +20,12 @@ describe Hallon::Toplist do
     end
 
     it "should pass the username given a string to libspotify" do
-      Spotify.registry_add 'spotify:toplist:user:Kim:tracks', mock_toplistbrowse
+      Spotify.mock_registry_add 'spotify:toplist:user:Kim:tracks', mock_toplistbrowse
       Hallon::Toplist.new(:tracks, "Kim").should be_loaded
     end
 
     it "should pass the correct region to libspotify" do
-      Spotify.registry_add 'spotify:toplist:tracks:SE', mock_toplistbrowse
+      Spotify.mock_registry_add 'spotify:toplist:tracks:SE', mock_toplistbrowse
       Hallon::Toplist.new(:tracks, :se).should be_loaded
     end
   end

data/spec/hallon/track_spec.rb

@@ -171,9 +171,9 @@ describe Hallon::Track do
 
   describe "#unwrap" do
     let(:track) { Hallon::Track.new(mock_track_two) }
-    let(:playlist) { Spotify.link_create_from_string!('spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi') }
-    let(:artist)   { Spotify.link_create_from_string!('spotify:artist:3bftcFwl4vqRNNORRsqm1G') }
-    let(:album)    { Spotify.link_create_from_string!('spotify:album:1xvnWMz2PNFf7mXOSRuLws') }
+    let(:playlist) { Spotify.link_create_from_string('spotify:user:burgestrand:playlist:07AX9IY9Hqmj1RqltcG0fi') }
+    let(:artist)   { Spotify.link_create_from_string('spotify:artist:3bftcFwl4vqRNNORRsqm1G') }
+    let(:album)    { Spotify.link_create_from_string('spotify:album:1xvnWMz2PNFf7mXOSRuLws') }
 
     it "does nothing if the track is not a placeholder" do
       track.stub(:placeholder? => false)
@@ -181,17 +181,17 @@ describe Hallon::Track do
     end
 
     it "should unwrap a playlist placeholder into a playlist" do
-      Spotify.should_receive(:link_create_from_track!).and_return(playlist)
+      spotify_api.should_receive(:link_create_from_track).and_return(playlist)
       track.unwrap.should eq Hallon::Playlist.new(playlist)
     end
 
     it "should unwrap an album placeholder into an album" do
-      Spotify.should_receive(:link_create_from_track!).and_return(album)
+      spotify_api.should_receive(:link_create_from_track).and_return(album)
       track.unwrap.should eq Hallon::Album.new(album)
     end
 
     it "should unwrap an artist placeholder into an artist" do
-      Spotify.should_receive(:link_create_from_track!).and_return(artist)
+      spotify_api.should_receive(:link_create_from_track).and_return(artist)
       track.unwrap.should eq Hallon::Artist.new(artist)
     end
   end

data/spec/hallon/user_post_spec.rb

@@ -22,7 +22,7 @@ describe Hallon::User::Post do
 
   describe ".create" do
     it "should return nil if the inboxpost failed" do
-      Spotify.should_receive(:inbox_post_tracks).and_return(null_pointer)
+      spotify_api.should_receive(:inbox_post_tracks).and_return(null_pointer)
       post.should be_nil
     end
 

data/spec/hallon/user_spec.rb

@@ -77,7 +77,7 @@ describe Hallon::User do
     let(:published) { Hallon::PlaylistContainer.new(mock_container) }
 
     it "should return the playlist container of the user" do
-      Spotify.registry_add("spotify:container:%s" % user.name, mock_container)
+      Spotify.mock_registry_add("spotify:container:%s" % user.name, mock_container)
 
       session.login('burgestrand', 'pass')
       user.published.should eq published

data/spec/mockspotify.rb

@@ -25,65 +25,59 @@ module Spotify
     end
   end
 
-  extend FFI::Library
-  extend Mock
+  class API
+    extend FFI::Library
+    extend Mock
+  end
+
   require 'spotify'
 
   module Mock
-    def self.find_type(*args, &block)
-      Spotify.find_type(*args, &block)
-    end
-
-    class PlaylistTrack < FFI::Struct
-      layout :track, :track,
+    class PlaylistTrack < Spotify::Struct
+      layout :track, Spotify::Track,
              :create_time, :int,
-             :creator, :user,
-             :message, :pointer,
+             :creator, Spotify::User,
+             :message, Spotify::NULString,
              :seen, :bool
     end
 
-    class PlaylistContainerItem < FFI::Struct
-      layout :playlist, :playlist,
+    class PlaylistContainerItem < Spotify::Struct
+      layout :playlist, Spotify::Playlist,
              :type, :playlist_type,
-             :folder_name, :pointer,
+             :folder_name, Spotify::NULString,
              :folder_id, :uint64,
              :num_seen_tracks, :int,
-             :seen_tracks, :pointer
+             :seen_tracks, :array
     end
   end
 
-  old_verbose, $VERBOSE = $VERBOSE, true
+  class API
+    old_verbose, $VERBOSE = $VERBOSE, true
 
-  def self.attach_mock_function(name, cname, params, returns, options = {})
-    attach_function(name, cname, params, returns, options)
-    define_singleton_method("#{name}!") do |*args|
-      Spotify::Pointer.new(send(name, *args), returns, false)
-    end
-  end
+    attach_function :mock_registry_find, [:string], :pointer
+    attach_function :mock_registry_add, [:string, :pointer], :void
+    attach_function :mock_registry_clean, [], :void
 
-  attach_function :registry_find, [:string], :pointer
-  attach_function :registry_add, [:string, :pointer], :void
-  attach_function :registry_clean, [], :void
+    attach_function :mock_session_create, [:pointer, :connectionstate, :int, OfflineSyncStatus, :int, :int, Playlist], Session
+    attach_function :mock_user_create, [:string, :string, :bool], User
+    attach_function :mock_track_create, [:string, :int, :array, Album, :int, :int, :int, :int, :error, :bool, :availability, :track_offline_status, :bool, :bool, Track, :bool, :bool], Track
+    attach_function :mock_image_create, [ImageID, :imageformat, :size_t, :buffer_in, :error], Image
+    attach_function :mock_artist_create, [:string, ImageID, :bool], Artist
+    attach_function :mock_album_create, [:string, Artist, :int, ImageID, :albumtype, :bool, :bool], Album
 
-  attach_function :mock_session, :mocksp_session_create, [:pointer, :connectionstate, :int, Spotify::OfflineSyncStatus, :int, :int, :playlist], :session
-  attach_mock_function :mock_user, :mocksp_user_create, [:string, :string, :bool], :user
-  attach_mock_function :mock_track, :mocksp_track_create, [:string, :int, :array, :album, :int, :int, :int, :int, :error, :bool, :availability, :track_offline_status, :bool, :bool, :track, :bool, :bool], :track
-  attach_mock_function :mock_image, :mocksp_image_create, [:image_id, :imageformat, :size_t, :buffer_in, :error], :image
-  attach_mock_function :mock_artist, :mocksp_artist_create, [:string, :image_id, :bool], :artist
-  attach_mock_function :mock_album, :mocksp_album_create, [:string, :artist, :int, :image_id, :albumtype, :bool, :bool], :album
+    attach_function :mock_albumbrowse_create, [:error, :int, Album, Artist, :int, :array, :int, :array, :string, :albumbrowse_complete_cb, :userdata], AlbumBrowse
+    attach_function :mock_artistbrowse_create, [:error, :int, Artist, :int, :array, :int, :array, :int, :array, :int, :array, :int, :array, :string, :artistbrowse_type, :artistbrowse_complete_cb, :userdata], ArtistBrowse
+    attach_function :mock_toplistbrowse_create, [:error, :int, :int, :array, :int, :array, :int, :array], ToplistBrowse
 
-  attach_function :mock_albumbrowse, :mocksp_albumbrowse_create, [:error, :int, :album, :artist, :int, :array, :int, :array, :string, :albumbrowse_complete_cb, :pointer], :albumbrowse
-  attach_function :mock_artistbrowse, :mocksp_artistbrowse_create, [:error, :int, :artist, :int, :array, :int, :array, :int, :array, :int, :array, :int, :array, :string, :artistbrowse_type, :artistbrowse_complete_cb, :pointer], :artistbrowse
-  attach_function :mock_toplistbrowse, :mocksp_toplistbrowse_create, [:error, :int, :int, :array, :int, :array, :int, :array], :toplistbrowse
+    attach_function :mock_playlist_create, [:string, :bool, User, :bool, :string, ImageID, :bool, :uint, Subscribers, :bool, :playlist_offline_status, :int, :int, :array], Playlist
+    attach_function :mock_playlistcontainer_create, [User, :bool, :int, :array, PlaylistContainerCallbacks, :userdata], PlaylistContainer
+    attach_function :mock_search_create, [:error, :string, :string, :int, :int, :array, :int, :int, :array, :int, :int, :array, :int, :int, :array, :search_complete_cb, :userdata], Search
+    attach_function :mock_subscribers, [:int, :array], Subscribers
 
-  attach_mock_function :mock_playlist, :mocksp_playlist_create, [:string, :bool, :user, :bool, :string, :image_id, :bool, :uint, Spotify::Subscribers, :bool, :playlist_offline_status, :int, :int, :array], :playlist
-  attach_mock_function :mock_playlistcontainer, :mocksp_playlistcontainer_create, [:user, :bool, :int, :array, PlaylistContainerCallbacks, :userdata], :playlistcontainer
-  attach_function :mock_search, :mocksp_search_create, [:error, :string, :string, :int, :int, :array, :int, :int, :array, :int, :int, :array, :int, :int, :array, :search_complete_cb, :pointer], :search
-  attach_function :mock_subscribers, :mocksp_subscribers, [:int, :array], Spotify::Subscribers
+    # mocked accessors
+    attach_function :mock_playlist_get_autolink_tracks, [Playlist], :bool
+    attach_function :mock_session_set_is_scrobbling_possible, [Session, :social_provider, :bool], :void
 
-  # mocked accessors
-  attach_function :mocksp_playlist_get_autolink_tracks, [:playlist], :bool
-  attach_function :mocksp_session_set_is_scrobbling_possible, [:session, :social_provider, :bool], :void
-
-  $VERBOSE = old_verbose
+    $VERBOSE = old_verbose
+  end
 end

data/spec/mockspotify/mockspotify_spec.rb

@@ -1,6 +1,6 @@
 describe Spotify::Mock do
   it "should have injected itself into Spotify's ancestor chain" do
-    ancestors = (class << Spotify; self; end).ancestors
+    ancestors = Spotify::API.singleton_class.ancestors
     mock_index = ancestors.index(Spotify::Mock)
     ffi_index  = ancestors.index(FFI::Library)
 
@@ -9,14 +9,14 @@ describe Spotify::Mock do
 
   describe "hextoa" do
     it "should convert a hexidecimal string properly" do
-      Spotify.attach_function :hextoa, [:string, :int], :string
+      Spotify::API.attach_function :hextoa, :hextoa, [:string, :int], :string
       Spotify.hextoa("3A3A", 4).should eq "::"
     end
   end
 
   describe "atohex" do
     it "should convert a byte string to a hexadecimal string" do
-      Spotify.attach_function :atohex, [:buffer_out, :buffer_in, :int], :void
+      Spotify::API.attach_function :atohex, :atohex, [:buffer_out, :buffer_in, :int], :void
 
       FFI::Buffer.alloc_out(8) do |b|
         Spotify.atohex(b, "\x3A\x3A\x0F\xF1", b.size)
@@ -27,7 +27,7 @@ describe Spotify::Mock do
 
   describe "unregion" do
     it "should convert an integer to the correct region" do
-      Spotify.attach_function :unregion, [ :int ], :string
+      Spotify::API.attach_function :unregion, :unregion, [ :int ], :string
 
       sweden = 21317
       Spotify.unregion(sweden).should eq "SE"
@@ -36,28 +36,28 @@ describe Spotify::Mock do
 
   describe "the registry" do
     it "should find previously added entries" do
-      Spotify.registry_add("i_exist", FFI::Pointer.new(1))
-      Spotify.registry_add("i_exist_too", FFI::Pointer.new(2))
+      Spotify.mock_registry_add("i_exist", FFI::Pointer.new(1))
+      Spotify.mock_registry_add("i_exist_too", FFI::Pointer.new(2))
 
-      Spotify.registry_find("i_exist").should eq FFI::Pointer.new(1)
-      Spotify.registry_find("i_exist_too").should eq FFI::Pointer.new(2)
+      Spotify.mock_registry_find("i_exist").should eq FFI::Pointer.new(1)
+      Spotify.mock_registry_find("i_exist_too").should eq FFI::Pointer.new(2)
     end
 
     it "should return nil for entries not in the registry" do
-      Spotify.registry_find("i_do_not_exist").should be_null
+      Spotify.mock_registry_find("i_do_not_exist").should be_null
     end
 
     it "should be cleanable" do
       pointer = FFI::MemoryPointer.new(:uint)
 
-      Spotify.registry_add("i_exist", pointer)
-      Spotify.registry_find("i_exist").should_not be_null
+      Spotify.mock_registry_add("i_exist", pointer)
+      Spotify.mock_registry_find("i_exist").should_not be_null
 
-      Spotify.registry_clean
-      Spotify.registry_find("i_exist").should be_null
+      Spotify.mock_registry_clean
+      Spotify.mock_registry_find("i_exist").should be_null
 
-      Spotify.registry_add("i_exist", pointer)
-      Spotify.registry_find("i_exist").should_not be_null
+      Spotify.mock_registry_add("i_exist", pointer)
+      Spotify.mock_registry_find("i_exist").should_not be_null
     end
   end
 end