Stability improvements, new release

README.md

@@ -3,7 +3,11 @@
 ### Ruby Version
 **IMPORTANT!**
 
-Ruby version 1.9+ required. No support for 1.8.7 anymore, update your application already!
+Ruby version 1.9+ required. No support for 1.8.7 anymore, if you still on 1.8 consider using gem [version 0.5.2](https://github.com/magnolia-fan/musicbrainz/tree/v0.5.2#musicbrainz-web-service-wrapper-) and bundle it like this:
+
+```ruby
+gem 'musicbrainz', '0.5.2'
+```
 
 ### Installation
 ```
@@ -11,7 +15,7 @@ gem install musicbrainz
 ```
 or add this line to your Gemfile
 ```ruby
-gem "musicbrainz"
+gem 'musicbrainz'
 ```
 
 ### Configuration
@@ -34,7 +38,7 @@ end
 
 ### Usage
 ```ruby
-require "musicbrainz"
+require 'musicbrainz'
 
 # Search for artists
 @suggestions = MusicBrainz::Artist.search("Jet")
@@ -47,50 +51,80 @@ require "musicbrainz"
 @empire_tracks = @kasabian.release_groups[8].releases.first.tracks
 ```
 
-### Api
+### Models
 
 MusicBrainz::Artist
 ```ruby
-@artists = MusicBrainz::Artist.search(query)
+# Class Methods:
-@artist = MusicBrainz::Artist.find_by_name(name)
+MusicBrainz::Artist.find(id)
-@artist = MusicBrainz::Artist.find(mbid)
+MusicBrainz::Artist.find_by_name(name)
-@artist.id
+MusicBrainz::Artist.search(name)
-@artist.type
+MusicBrainz::Artist.discography(id)
-@artist.name
+
-@artist.country
+# Instance Methods:
-@artist.date_begin
-@artist.date_end
 @artist.release_groups
+
+# Fields
+{
+  :id         => String,
+  :type       => String,
+  :name       => String,
+  :country    => String,
+  :date_begin => Date,
+  :date_end   => Date,
+  :urls       => Hash
+}
 ```
 
 MusicBrainz::ReleaseGroup
 ```ruby
-@release_group = MusicBrainz::ReleaseGroup.find(mbid)
+# Class Methods
-@release_group.id
+MusicBrainz::ReleaseGroup.find(id)
-@release_group.type
+
-@release_group.title
+# Instance Methods
-@release_group.first_release_date
 @release_group.releases
+
+# Fields
+{
+  :id                 => String,
+  :type               => String,
+  :title              => String,
+  :desc               => String,
+  :first_release_date => Date
+}
 ```
 
 MusicBrainz::Release
 ```ruby
-@release = MusicBrainz::Release.find(mbid)
+# Class Methods
-@release.id
+MusicBrainz::Release.find(id)
-@release.title
+
-@release.status
+# Instance Methods
-@release.date
-@release.country
 @release.tracks
+
+# Fields
+{
+  :id      => String,
+  :title   => String,
+  :status  => String,
+  :format  => String,
+  :date    => Date,
+  :country => String
+}
 ```
 
 MusicBrainz::Track
 ```ruby
-@track = MusicBrainz::Track.find(mbid)
+# Class Methods
-@track.position
+MusicBrainz::Track.find(id)
-@track.recording_id
+
-@track.title
+# Fields
-@track.length
+{
+  :position     => Integer,
+  :recording_id => String,
+  :title        => String,
+  :length       => Integer
+}
 ```
 
 ### Testing

lib/mb.rb

@@ -0,0 +1,2 @@
+require "musicbrainz"
+MB = MusicBrainz

lib/musicbrainz/client.rb

@@ -1,5 +1,9 @@
 module MusicBrainz
-  module Client
+  class Client
+    include ClientModules::TransparentProxy
+    include ClientModules::FailsafeProxy
+    include ClientModules::CachingProxy
+
     def http
       @faraday ||= Faraday.new do |f|
         f.request :url_encoded            # form-encode POST params
@@ -11,14 +15,18 @@ module MusicBrainz
     def load(resource, query, params)
       raise Exception.new("You need to run MusicBrainz.configure before querying") if MusicBrainz.config.nil?
 
-      response = contents_of(build_url(resource, query))
+      url = build_url(resource, query)
-      xml = Nokogiri::XML.parse(response).remove_namespaces!.xpath('/metadata')
+      response = get_contents(url)
-      data = params[:binding].parse(xml)
+
+      return nil if response[:status] != 200
+
+      xml = Nokogiri::XML.parse(response[:body]).remove_namespaces!.xpath('/metadata')
+      data = binding_class_for(params[:binding]).parse(xml)
 
       if params[:create_model]
-        params[:create_model].new(data)
+        model_class_for(params[:create_model]).new(data)
       elsif params[:create_models]
-        models = data.map{ |item| params[:create_models].new(item) }
+        models = data.map{ |item| model_class_for(params[:create_models]).new(item) }
         models.sort!{ |a, b| a.send(params[:sort]) <=> b.send(params[:sort]) } if params[:sort]
         models
       else
@@ -26,13 +34,7 @@ module MusicBrainz
       end
     end
 
-    def contents_of(url)
+  private
-      if method_defined? :get_contents
-        get_contents url
-      else
-        http.get url
-      end
-    end
 
     def build_url(resource, params)
       "#{MusicBrainz.config.web_service_url}#{resource.to_s.gsub('_', '-')}" <<
@@ -40,17 +42,31 @@ module MusicBrainz
       params.map do |key, value|
         key = key.to_s.gsub('_', '-')
         value = if value.is_a?(Array)
-          value.map{ |el| el.to_s.gsub('_', '-') }.join('+')
+          value.map{ |el| el.to_s.gsub('_', '-') }.join(?+)
         else
           value.to_s
         end
-        "#{key}=#{value}"
+        [key, value].join(?=)
-      end.join('&')
+      end.join(?&)
     end
 
-    include ClientModules::TransparentProxy
+    def binding_class_for(key)
-    include ClientModules::FailsafeProxy
+      MusicBrainz::Bindings.const_get(constantized(key))
-    include ClientModules::CachingProxy
+    end
-    extend self
+
+    def model_class_for(key)
+      MusicBrainz.const_get(constantized(key))
+    end
+
+    def constantized(key)
+      key.to_s.split(?_).map(&:capitalize).join.to_sym
+    end
   end
+
+  module ClientHelper
+    def client
+      @client ||= Client.new
+    end
+  end
+  extend ClientHelper
 end

lib/musicbrainz/client_modules/caching_proxy.rb

@@ -10,22 +10,26 @@ module MusicBrainz
       end
 
       def get_contents(url)
-        return super unless MusicBrainz.config.perform_caching
+        return super unless caching?
 
-        token = Digest::SHA256.hexdigest(url)
+        hash = Digest::SHA256.hexdigest(url)
-        file_path = "#{cache_path}/#{token[0..1]}/#{token[2..3]}/#{token[4..-1]}.xml"
+        dir_path = [cache_path, *(0..2).map{ |i| hash.slice(2*i, 2) }].join(?/)
+        file_path = [dir_path, '/', hash.slice(6, 58), '.xml'].join
 
-        response = nil
+        response = { body: nil, status: 500 }
 
         if File.exist?(file_path)
-          response = File.open(file_path, 'rb').gets
+          response = {
+            body: File.open(file_path, 'rb').gets,
+            status: 200
+          }
         else
           response = super
-          unless response.nil? or response.empty?
+          if response[:status] == 200
-            FileUtils.mkdir_p file_path.split('/')[0..-2].join('/')
+            FileUtils.mkpath(dir_path)
             File.open(file_path, 'wb') do |f|
-              f.puts response
+              f.puts(response[:body])
-              f.chmod 0755
+              f.chmod(0755)
               f.close
             end
           end
@@ -33,6 +37,10 @@ module MusicBrainz
 
         response
       end
+
+      def caching?
+        MusicBrainz.config.perform_caching
+      end
     end
   end
 end

lib/musicbrainz/client_modules/failsafe_proxy.rb

@@ -2,21 +2,36 @@ module MusicBrainz
   module ClientModules
     module FailsafeProxy
       def get_contents(url)
-        response = nil
+        return super unless failsafe?
 
+        response = { body: nil, status: 500 }
         MusicBrainz.config.tries_limit.times do
-          time_passed = Time.now.to_f - @last_query_time ||= 0.0
-          if time_passed < MusicBrainz.config.query_interval
-            sleep(MusicBrainz.config.query_interval - time_passed)
-          end
-
           response = super
-          @last_query_time = Time.now.to_f
+          break if response[:status] == 200
-
-          break if response.status == 200
         end
 
-        response.body rescue nil
+        response
+      end
+
+      def time_passed
+        Time.now.to_f - @last_query_time ||= 0.0
+      end
+
+      def time_to_wait
+        MusicBrainz.config.query_interval - time_passed
+      end
+
+      def ready?
+        time_passed > MusicBrainz.config.query_interval
+      end
+
+      def wait_util_ready!
+        sleep(time_to_wait) unless ready?
+        @last_query_time = Time.now.to_f
+      end
+
+      def failsafe?
+        MusicBrainz.config.tries_limit > 1 && MusicBrainz.config.query_interval.to_f > 0
       end
     end
   end

lib/musicbrainz/client_modules/transparent_proxy.rb

@@ -2,7 +2,10 @@ module MusicBrainz
   module ClientModules
     module TransparentProxy
       def get_contents(url)
-        http.get url
+        response = http.get(url)
+        { body: response.body, status: response.status }
+      rescue
+        { body: nil, status: 500 }
       end
     end
   end

lib/musicbrainz/configuration.rb

@@ -19,24 +19,42 @@ module MusicBrainz
       @perform_caching = DEFAULT_PERFORM_CACHING
     end
 
-    def user_agent_string
+    def valid?
       %w[ app_name app_version contact ].each do |param|
-        raise "#{param} must be set" if instance_variable_get("@#{param}").nil?
+        unless instance_variable_defined?(:"@#{param}")
+          raise Exception.new("Application identity parameter '#{param}' missing")
+        end
       end
-
+      unless tries_limit.nil? && query_interval.nil?
-      "#{@app_name}/#{@app_version} ( #{@contact} )"
+        raise Exception.new("'tries_limit' parameter must be 1 or greater") if tries_limit.to_i < 1
+        raise Exception.new("'query_interval' parameter must be greater than zero") if query_interval.to_f < 0
+      end
+      if perform_caching
+        raise Exception.new("'cache_path' parameter must be set") if cache_path.nil?
+      end
+      true
     end
   end
 
   module Configurable
     def configure
-      raise "Configuration missing" unless block_given?
+      raise Exception.new("Configuration block missing") unless block_given?
       yield @config ||= MusicBrainz::Configuration.new
+      config.valid?
     end
 
     def config
+      raise Exception.new("Configuration missing") unless instance_variable_defined?(:@config)
       @config
     end
+
+    def apply_test_configuration!
+      configure do |c|
+        c.app_name = "gem musicbrainz (development mode)"
+        c.app_version = MusicBrainz::VERSION
+        c.contact = `git config user.email`.chomp
+      end
+    end
   end
   extend Configurable
 end

lib/musicbrainz/middleware.rb

@@ -1,10 +1,23 @@
 module MusicBrainz
   class Middleware < Faraday::Middleware
     def call(env)
-      env[:request_headers]["User-Agent"] = MusicBrainz.config.user_agent_string
+      env[:request_headers].merge!(
-      env[:request_headers]["Via"] = "gem musicbrainz/#{VERSION} (#{GH_PAGE_URL})"
+        "User-Agent" => user_agent_string,
-
+        "Via"        => via_string
+      )
       @app.call(env)
     end
+
+    def user_agent_string
+      "#{config.app_name}/#{config.app_version} ( #{config.contact} )"
+    end
+
+    def via_string
+      "gem musicbrainz/#{VERSION} (#{GH_PAGE_URL})"
+    end
+
+    def config
+      MusicBrainz.config
+    end
   end
 end

lib/musicbrainz/models/artist.rb

@@ -1,38 +1,34 @@
 module MusicBrainz
-  class Artist
+  class Artist < BaseModel
-    include BaseModel
-
     field :id, String
     field :type, String
     field :name, String
     field :country, String
-    field :date_begin, Time
+    field :date_begin, Date
-    field :date_end, Time
+    field :date_end, Date
     field :urls, Hash
 
-    attr_writer :release_groups
-
     def release_groups
-      @release_groups ||= Client::load(:release_group, { artist: id }, {
+      @release_groups ||= client.load(:release_group, { artist: id }, {
-        binding: MusicBrainz::Bindings::ArtistReleaseGroups,
+        binding: :artist_release_groups,
-        create_models: MusicBrainz::ReleaseGroup,
+        create_models: :release_group,
         sort: :first_release_date
       }) unless @id.nil?
     end
 
     class << self
       def find(id)
-        Client.load(:artist, { id: id, inc: [:url_rels] }, {
+        client.load(:artist, { id: id, inc: [:url_rels] }, {
-          binding: MusicBrainz::Bindings::Artist,
+          binding: :artist,
-          create_model: MusicBrainz::Artist
+          create_model: :artist
         })
       end
 
       def search(name)
         name = CGI.escape(name).gsub(/\!/, '\!')
 
-        Client.load(:artist, { query: "artist:#{name}", limit: 10 }, {
+        client.load(:artist, { query: "artist:#{name}", limit: 10 }, {
-          binding: MusicBrainz::Bindings::ArtistSearch
+          binding: :artist_search
         })
       end
 

lib/musicbrainz/models/base_model.rb

@@ -1,29 +1,43 @@
 module MusicBrainz
-  module BaseModel
+  class BaseModel
-    def self.included(klass)
+    def self.inherited(klass)
       klass.send(:include, InstanceMethods)
       klass.send(:extend, ClassMethods)
     end
 
     module ClassMethods
       def field(name, type)
-        self.class_exec do
+        fields[name] = type
-          attr_reader name
+        attr_reader name
 
-          define_method("#{name}=") do |val|
+        define_method("#{name}=") do |val|
-            instance_variable_set("@#{name}", validate_type(val, type))
+          instance_variable_set("@#{name}", validate_type(val, type))
-          end
         end
       end
+
+      def fields
+        instance_variable_set(:@fields, {}) unless instance_variable_defined?(:@fields)
+        instance_variable_get(:@fields)
+      end
+
+      def client
+        MusicBrainz.client
+      end
     end
 
     module InstanceMethods
       def initialize(params = {})
         params.each do |field, value|
-          self.send :"#{field}=", value
+          self.send(:"#{field}=", value)
         end
       end
 
+      def client
+        MusicBrainz.client
+      end
+
+    private
+
       def validate_type(val, type)
         if type == Integer
           val.to_i
@@ -31,7 +45,7 @@ module MusicBrainz
           val.to_f
         elsif type == String
           val.to_s
-        elsif type == Time
+        elsif type == Date
           if val.nil? or val == ""
             val = "2030-12-31"
           elsif val.split("-").length == 1
@@ -39,7 +53,7 @@ module MusicBrainz
           elsif val.split("-").length == 2
             val << "-31"
           end
-          Time.utc(*val.split("-"))
+          Date.new(*val.split(?-).map(&:to_i))
         else
           val
         end

lib/musicbrainz/models/release.rb

@@ -1,29 +1,25 @@
 module MusicBrainz
-  class Release
+  class Release < BaseModel
-    include BaseModel
-
     field :id, String
     field :title, String
     field :status, String
     field :format, String
-    field :date, Time
+    field :date, Date
     field :country, String
 
-    attr_writer :tracks
-
     def tracks
-      @tracks ||= Client::load(:release, { id: id, inc: [:recordings, :media], limit: 100 }, {
+      @tracks ||= client.load(:release, { id: id, inc: [:recordings, :media], limit: 100 }, {
-        binding: MusicBrainz::Bindings::ReleaseTracks,
+        binding: :release_tracks,
-        create_models: MusicBrainz::Track,
+        create_models: :track,
         sort: :position
       }) unless @id.nil?
     end
 
     class << self
       def find(id)
-        Client.load(:release, { id: id, inc: [:media] }, {
+        client.load(:release, { id: id, inc: [:media] }, {
-          binding: MusicBrainz::Bindings::Release,
+          binding: :release,
-          create_model: MusicBrainz::Release
+          create_model: :release
         })
       end
     end

lib/musicbrainz/models/release_group.rb

@@ -1,29 +1,26 @@
 module MusicBrainz
-  class ReleaseGroup
+  class ReleaseGroup < BaseModel
-    include BaseModel
-
     field :id, String
     field :type, String
     field :title, String
     field :desc, String
-    field :first_release_date, Time
+    field :first_release_date, Date
 
     alias_method :disambiguation, :desc
-    attr_writer :releases
 
     def releases
-      @releases ||= Client::load(:release, { release_group: id, inc: [:media], limit: 100 }, {
+      @releases ||= client.load(:release, { release_group: id, inc: [:media], limit: 100 }, {
-        binding: MusicBrainz::Bindings::ReleaseGroupReleases,
+        binding: :release_group_releases,
-        create_models: MusicBrainz::Release,
+        create_models: :release,
         sort: :date
       }) unless @id.nil?
     end
 
     class << self
       def find(id)
-        Client.load(:release_group, { id: id }, {
+        client.load(:release_group, { id: id }, {
-          binding: MusicBrainz::Bindings::ReleaseGroup,
+          binding: :release_group,
-          create_model: MusicBrainz::ReleaseGroup
+          create_model: :release_group
         })
       end
     end

lib/musicbrainz/models/track.rb

@@ -1,7 +1,5 @@
 module MusicBrainz
-  class Track
+  class Track < BaseModel
-    include BaseModel
-
     field :position, Integer
     field :recording_id, String
     field :title, String
@@ -9,9 +7,9 @@ module MusicBrainz
 
     class << self
       def find(id)
-        Client.load(:recording, { id: id }, {
+        client.load(:recording, { id: id }, {
-          binding: MusicBrainz::Bindings::Track,
+          binding: :track,
-          create_model: MusicBrainz::Track
+          create_model: :track
         })
       end
     end

lib/musicbrainz/version.rb

@@ -1,3 +1,3 @@
 module MusicBrainz
-  VERSION = "0.8"
+  VERSION = "0.7.2"
 end

musicbrainz.gemspec

@@ -3,18 +3,19 @@ require File.expand_path('../lib/musicbrainz/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Gregory Eremin"]
   gem.email         = ["magnolia_fan@me.com"]
-  gem.summary       = %q{MusicBrainz Web Service wrapper with ActiveRecord-style models}
+  gem.summary       = %q{ MusicBrainz Web Service wrapper with ActiveRecord-style models }
   gem.homepage      = "http://github.com/magnolia-fan/musicbrainz"
 
   gem.files         = %x{ git ls-files }.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables   = []
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.test_files    = gem.files.grep(%r{^spec/})
   gem.name          = "musicbrainz"
   gem.require_paths = %w[ lib ]
   gem.version       = MusicBrainz::VERSION
   gem.license       = "MIT"
 
-  gem.add_dependency("faraday")
+  gem.add_dependency('faraday')
-  gem.add_dependency("nokogiri")
+  gem.add_dependency('nokogiri')
-  gem.add_development_dependency("rspec")
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('awesome_print')
 end

spec/client_modules/cache_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require "ostruct"
+require "spec_helper"
+
+describe MusicBrainz::ClientModules::CachingProxy do
+  let(:old_cache_path){ File.join(File.dirname(__FILE__), '..', '..', 'tmp', 'spec_cache') }
+  let(:tmp_cache_path){ File.join(File.dirname(__FILE__), '..', '..', 'tmp', 'cache_module_spec_cache') }
+  let(:test_mbid){ "69b39eab-6577-46a4-a9f5-817839092033" }
+  let(:test_cache_file){ "#{tmp_cache_path}/03/48/ec/6c2bee685d9a96f95ed46378f624714e7a4650b0d44c1a8eee5bac2480.xml" }
+  let(:test_response_file){ File.join(File.dirname(__FILE__), "../fixtures/kasabian.xml") }
+  let(:test_response){ File.open(test_response_file).read }
+
+  before(:all) do
+    MusicBrainz.config.cache_path = tmp_cache_path
+  end
+
+  after(:all) do
+    MusicBrainz.config.cache_path = old_cache_path
+    MusicBrainz.config.perform_caching = true
+    MusicBrainz.config.query_interval = 1.5
+  end
+
+  context "with cache enabled" do
+    it "calls http only once when requesting the resource twice" do
+      MusicBrainz.config.perform_caching = true
+      File.exist?(test_cache_file).should be_false
+
+      # Stubbing
+      MusicBrainz.client.http.stub(:get).and_return(OpenStruct.new(status: 200, body: test_response))
+      MusicBrainz.client.http.should_receive(:get).once
+
+      2.times do
+        artist = MusicBrainz::Artist.find(test_mbid)
+        artist.should be_a_kind_of(MusicBrainz::Artist)
+        File.exist?(test_cache_file).should be_true
+      end
+
+      MusicBrainz.client.clear_cache
+    end
+  end
+
+  context "with cache disabled" do
+    it "calls http twice when requesting the resource twice" do
+      MusicBrainz.config.perform_caching = false
+      File.exist?(test_cache_file).should be_false
+
+      # Hacking for test performance purposes
+      MusicBrainz.config.query_interval = 0.0
+
+      # Stubbing
+      MusicBrainz.client.http.stub(:get).and_return(OpenStruct.new(status: 200, body: test_response))
+      MusicBrainz.client.http.should_receive(:get).twice
+
+      2.times do
+        artist = MusicBrainz::Artist.find(test_mbid)
+        artist.should be_a_kind_of(MusicBrainz::Artist)
+        File.exist?(test_cache_file).should be_false
+      end
+    end
+  end
+end

spec/models/artist_spec.rb

@@ -55,6 +55,6 @@ describe MusicBrainz::Artist do
     release_groups.first.id.should == "533cbc5f-ec7e-32ab-95f3-8d1f804a5176"
     release_groups.first.type.should == "Single"
     release_groups.first.title.should == "Club Foot"
-    release_groups.first.first_release_date.should == Time.utc(2004, 5, 10)
+    release_groups.first.first_release_date.should == Date.new(2004, 5, 10)
   end
 end

spec/models/release_group_spec.rb

@@ -19,7 +19,7 @@ describe MusicBrainz::ReleaseGroup do
     release_group.id.should == "6f33e0f0-cde2-38f9-9aee-2c60af8d1a61"
     release_group.type.should == "Album"
     release_group.title.should == "Empire"
-    release_group.first_release_date.should == Time.utc(2006, 8, 28)
+    release_group.first_release_date.should == Date.new(2006, 8, 28)
   end
 
   it "gets correct release group's releases" do
@@ -28,7 +28,7 @@ describe MusicBrainz::ReleaseGroup do
     releases.first.id.should == "2225dd4c-ae9a-403b-8ea0-9e05014c778f"
     releases.first.status.should == "Official"
     releases.first.title.should == "Empire"
-    releases.first.date.should == Time.utc(2006, 8, 28)
+    releases.first.date.should == Date.new(2006, 8, 28)
     releases.first.country.should == "GB"
   end
 end

spec/models/release_spec.rb

@@ -19,7 +19,7 @@ describe MusicBrainz::Release do
     release.id.should == "2225dd4c-ae9a-403b-8ea0-9e05014c778f"
     release.title.should == "Empire"
     release.status.should == "Official"
-    release.date.should == Time.utc(2006, 8, 28)
+    release.date.should == Date.new(2006, 8, 28)
     release.country.should == "GB"
   end
 

spec/spec_helper.rb

@@ -2,16 +2,18 @@ require "rubygems"
 require "bundler/setup"
 require "musicbrainz"
 
+RSpec.configure do |c|
+  c.order = 'random'
+end
+
 MusicBrainz.configure do |c|
-  test_email = %x{ git config --global --get user.email }.gsub(/\n/, "")
+  test_email = `git config user.email`.chomp
   test_email = "magnolia_fan@me.com" if test_email.empty?
 
   c.app_name = "MusicBrainzGemTestSuite"
   c.app_version = MusicBrainz::VERSION
   c.contact = test_email
+
+  c.cache_path = File.join(File.dirname(__FILE__), '..', 'tmp', 'spec_cache')
   c.perform_caching = true
 end
-
-RSpec.configure do |config|
-  # Configuration is not currently necessary
-end

spec/tools/cache_spec.rb

@@ -1,64 +0,0 @@
-# encoding: utf-8
-
-require "ostruct"
-require "spec_helper"
-
-describe MusicBrainz::Tools::Cache do
-  before(:all) do
-    @old_cache_path = MusicBrainz::Tools::Cache.cache_path
-    @tmp_cache_path = File.join(File.dirname(__FILE__), "../../tmp/cache/test")
-    @test_mbid = "69b39eab-6577-46a4-a9f5-817839092033"
-    @test_cache_file = "#{@tmp_cache_path}/03/48/ec6c2bee685d9a96f95ed46378f624714e7a4650b0d44c1a8eee5bac2480.xml"
-  end
-
-  after(:all) do
-    MusicBrainz.config.cache_path = @old_cache_path
-  end
-
-  before(:each) do
-    file_path = File.join(File.dirname(__FILE__), "../fixtures/kasabian.xml")
-    @test_response = File.open(file_path).read
-  end
-
-  context "with cache enabled" do
-    it "calls http only once when requesting the resource twice" do
-      MusicBrainz.config.cache_path = @tmp_cache_path
-      File.exist?(@test_cache_file).should be_false
-
-      # Stubbing
-      MusicBrainz::Client.http.stub(:get).and_return(OpenStruct.new(status: 200, body: @test_response))
-      MusicBrainz::Client.http.should_receive(:get).once
-
-      2.times do
-        artist = MusicBrainz::Artist.find(@test_mbid)
-        artist.should be_a_kind_of(MusicBrainz::Artist)
-        File.exist?(@test_cache_file).should be_true
-      end
-
-      MusicBrainz::Client.clear_cache
-    end
-  end
-
-  context "with cache disabled" do
-    it "calls http twice when requesting the resource twice" do
-      MusicBrainz.config.perform_caching = false
-      File.exist?(@test_cache_file).should be_false
-
-      # Hacking for test performance purposes
-      MusicBrainz.config.query_interval = 0.0
-
-      # Stubbing
-      MusicBrainz::Client.http.stub(:get).and_return(OpenStruct.new(status: 200, body: @test_response))
-      MusicBrainz::Client.http.should_receive(:get).twice
-
-      2.times do
-        artist = MusicBrainz::Artist.find(@test_mbid)
-        artist.should be_a_kind_of(MusicBrainz::Artist)
-        File.exist?(@test_cache_file).should be_false
-      end
-
-      MusicBrainz.config.perform_caching = true
-      MusicBrainz.config.query_interval = 1.5
-    end
-  end
-end