exchange 0.2.6 → 0.3.0

data/spec/exchange/cache/file_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe "Exchange::Cache::File" do
+  subject { Exchange::Cache::File }
+  before(:each) do
+    Exchange::Configuration.define do |c|
+      c.cache      = :file
+    end
+  end
+  after(:each) do
+    Exchange::Configuration.define do |c|
+      c.cache      = :memcached
+    end
+  end
+  describe "cached" do
+    it "should raise an error if no block was given" do
+      lambda { subject.cached('API_CLASS') }.should raise_error(Exchange::Cache::CachingWithoutBlockError)
+    end
+    context "when a result is returned" do
+      context "with a daily cache" do
+        before(:each) do
+          subject.should_receive(:key).with('API_CLASS', nil).and_return('KEY')
+          Exchange::Configuration.should_receive(:filestore_path).and_return('STORE')
+          ::File.should_receive(:exists?).with('STORE/KEY').and_return(true)
+          ::File.should_receive(:read).with('STORE/KEY').and_return 'CONTENT'
+        end
+        it "should return the file contents" do
+          subject.cached('API_CLASS') { 'something' }.should == 'CONTENT'
+        end
+      end
+      context "with an monthly cache" do
+        before(:each) do
+          subject.should_receive(:key).with('API_CLASS', an_instance_of(Symbol)).and_return('KEY')
+          Exchange::Configuration.should_receive(:filestore_path).and_return('STORE')
+          ::File.should_receive(:exists?).with('STORE/KEY').and_return(true)
+          ::File.should_receive(:read).with('STORE/KEY').and_return 'CONTENT'
+        end
+        it "should return the file contents" do
+          subject.cached('API_CLASS', :cache_period => :monthly) { 'something' }.should == 'CONTENT'
+        end
+      end
+    end
+    context "when no file is cached yet" do
+      before(:each) do
+        subject.should_receive(:key).with('API_CLASS', an_instance_of(Symbol)).at_most(3).times.and_return('KEY')
+        Exchange::Configuration.should_receive(:filestore_path).and_return('STORE')
+        ::File.should_receive(:exists?).with('STORE/KEY').and_return(false)
+        Dir.should_receive(:entries).with('STORE').once.and_return(%W(entry entry2))
+        ::File.should_receive(:delete).with(an_instance_of(String)).twice
+        FileUtils.should_receive(:mkdir_p).once
+        ::File.should_receive(:open).once
+      end
+      it "should return the file contents" do
+        subject.cached('API_CLASS', :cache_period => :monthly) { 'RESULT' }.should == 'RESULT'
+      end
+    end
+    context "when no result is returned" do
+      before(:each) do
+        subject.should_receive(:key).with('API_CLASS', an_instance_of(Symbol)).at_most(3).times.and_return('KEY')
+        Exchange::Configuration.should_receive(:filestore_path).and_return('STORE')
+        ::File.should_receive(:exists?).with('STORE/KEY').and_return(false)
+        FileUtils.should_receive(:mkdir_p).never
+        ::File.should_receive(:open).never
+      end
+      it "should return the file contents" do
+        subject.cached('API_CLASS', :cache_period => :monthly) { '' }.should == ''
+      end
+    end
+  end
+end

data/spec/exchange/cache/memcached_spec.rb

@@ -25,10 +25,13 @@ describe "Exchange::Cache::Memcached" do
     end
   end
   describe "cached" do
+    it "should raise an error if no block was given" do
+      lambda { subject.cached('API_CLASS') }.should raise_error(Exchange::Cache::CachingWithoutBlockError)
+    end
     context "when a cached result exists" do
       let(:client) { mock('memcached') }
       before(:each) do
-        subject.should_receive(:key).with('API_CLASS', nil).and_return('KEY')
+        subject.should_receive(:key).with('API_CLASS', {}).and_return('KEY')
         ::Memcached.should_receive(:new).with("HOST:PORT").and_return(client)
         client.should_receive(:get).with('KEY').and_return "{\"RESULT\":\"YAY\"}"
       end
@@ -42,7 +45,7 @@ describe "Exchange::Cache::Memcached" do
     context "when no cached result exists" do
       let(:client) { mock('memcached') }
       before(:each) do
-        subject.should_receive(:key).with('API_CLASS', nil).twice.and_return('KEY')
+        subject.should_receive(:key).with('API_CLASS', {}).twice.and_return('KEY')
         ::Memcached.should_receive(:new).with("HOST:PORT").and_return(client)
         client.should_receive(:get).with('KEY').and_raise(::Memcached::NotFound)
       end

data/spec/exchange/cache/no_cache_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "Exchange::Cache::Rails" do
+  context "with rails defined" do
+    class ::Rails
+    end
+  end
+  subject { Exchange::Cache::NoCache }
+  before(:each) do
+    Exchange::Configuration.define do |c|
+      c.cache      = false
+    end
+  end
+  after(:each) do
+    Exchange::Configuration.define do |c|
+      c.cache      = :memcached
+    end
+  end
+  describe "cached" do
+    it "should directly call the block" do
+      subject.cached('API_CLASS') { 'something' }.should == 'something'
+    end
+    it "should raise an error if no block was given" do
+      lambda { subject.cached('API_CLASS') }.should raise_error(Exchange::Cache::CachingWithoutBlockError)
+    end
+  end
+end

data/spec/exchange/cache/rails_spec.rb

@@ -24,11 +24,14 @@ describe "Exchange::Cache::Rails" do
     end
   end
   describe "cached" do
+    it "should raise an error if no block was given" do
+      lambda { subject.cached('API_CLASS') }.should raise_error(Exchange::Cache::CachingWithoutBlockError)
+    end
     context "when a result is returned" do
       let(:client) { mock('rails_cache') }
       context "with a daily cache" do
         before(:each) do
-          subject.should_receive(:key).with('API_CLASS', nil).and_return('KEY')
+          subject.should_receive(:key).with('API_CLASS', {}).and_return('KEY')
           ::Rails.should_receive(:cache).and_return(client)
           client.should_receive(:fetch).with('KEY', :expires_in => 86400).and_return "{\"RESULT\":\"YAY\"}"
         end
@@ -39,7 +42,7 @@ describe "Exchange::Cache::Rails" do
       context "with an hourly cache" do
         before(:each) do
           Exchange::Configuration.update = :hourly
-          subject.should_receive(:key).with('API_CLASS', nil).and_return('KEY')
+          subject.should_receive(:key).with('API_CLASS', {}).and_return('KEY')
           ::Rails.should_receive(:cache).and_return(client)
           client.should_receive(:fetch).with('KEY', :expires_in => 3600).and_return "{\"RESULT\":\"YAY\"}"
         end
@@ -54,7 +57,7 @@ describe "Exchange::Cache::Rails" do
     context "when no result is returned" do
       let(:client) { mock('rails_cache') }
       before(:each) do
-        subject.should_receive(:key).with('API_CLASS', nil).at_most(3).times.and_return('KEY')
+        subject.should_receive(:key).with('API_CLASS', {}).at_most(3).times.and_return('KEY')
         ::Rails.should_receive(:cache).twice.and_return(client)
         client.should_receive(:fetch).with('KEY', an_instance_of(Hash)).and_return nil
         client.should_receive(:delete).with('KEY').once

data/spec/exchange/cache/redis_spec.rb

@@ -27,10 +27,13 @@ describe "Exchange::Cache::Redis" do
     end
   end
   describe "cached" do
+    it "should raise an error if no block was given" do
+      lambda { subject.cached('API_CLASS') }.should raise_error(Exchange::Cache::CachingWithoutBlockError)
+    end
     context "when a cached result exists" do
       let(:client) { mock('redis') }
       before(:each) do
-        subject.should_receive(:key).with('API_CLASS', nil).and_return('KEY')
+        subject.should_receive(:key).with('API_CLASS', {}).and_return('KEY')
         ::Redis.should_receive(:new).with(:host => 'HOST', :port => 'PORT').and_return(client)
         client.should_receive(:get).with('KEY').and_return "{\"RESULT\":\"YAY\"}"
       end
@@ -44,7 +47,7 @@ describe "Exchange::Cache::Redis" do
     context "when no cached result exists" do
       let(:client) { mock('redis') }
       before(:each) do
-        subject.should_receive(:key).with('API_CLASS', nil).at_most(3).times.and_return('KEY')
+        subject.should_receive(:key).with('API_CLASS', {}).at_most(3).times.and_return('KEY')
         ::Redis.should_receive(:new).with(:host => 'HOST', :port => 'PORT').and_return(client)
         client.should_receive(:get).with('KEY').and_return nil
       end

data/spec/exchange/currency_spec.rb

@@ -18,7 +18,7 @@ describe "Exchange::Currency" do
   describe "convert_to" do
     it "should be able to convert itself to other currencies" do
       mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 3)
-      subject.convert_to(:chf).value.should == 36.5
+      subject.convert_to(:chf).value.round(2).should == 36.5
       subject.convert_to(:chf).currency.should == :chf
       subject.convert_to(:chf).should be_kind_of Exchange::Currency
     end
@@ -33,7 +33,7 @@ describe "Exchange::Currency" do
       end
       it "should be able to add another currency value" do
         mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
-        (subject + Exchange::Currency.new(30, :chf)).value.should == 72.87
+        (subject + Exchange::Currency.new(30, :chf)).value.round(2).should == 72.87
         (subject + Exchange::Currency.new(30, :sek)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
@@ -57,7 +57,7 @@ describe "Exchange::Currency" do
       end
       it "should be able to subtract another currency value" do
         mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
-        (subject + Exchange::Currency.new(10, :chf)).value.should == 50.96
+        (subject + Exchange::Currency.new(10, :chf)).value.round(2).should == 50.96
         (subject + Exchange::Currency.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
@@ -81,7 +81,7 @@ describe "Exchange::Currency" do
       end
       it "should be able to multiply by another currency value" do
         mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
-        (((subject * Exchange::Currency.new(10, :chf)).value * 10000.0).round.to_f / 10000.0).should == 438.4
+        (subject * Exchange::Currency.new(10, :chf)).value.round(1).should == 438.3
         (subject * Exchange::Currency.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
@@ -101,11 +101,11 @@ describe "Exchange::Currency" do
         (subject / 40).value.should == 1
       end
       it "should be able to multiply a float" do
-        (((subject / 40.5).value * 10000.0).round.to_f / 10000.0).should == 0.9877
+        BigDecimal.new((subject / 40.5).value.to_s).round(4).should == 0.9877
       end
       it "should be able to multiply by another currency value" do
         mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
-        (((subject / Exchange::Currency.new(10, :chf)).value * 10000.0).round.to_f / 10000.0).should == 3.6496
+        (subject / Exchange::Currency.new(10, :chf)).value.round(2).should == BigDecimal.new("3.65")
         (subject / Exchange::Currency.new(23.3, :eur)).currency.should == :usd
       end
       it "should raise when currencies get mixed and the configuration does not allow it" do
@@ -126,7 +126,7 @@ describe "Exchange::Currency" do
       let(:comp2) { Exchange::Currency.new(40, :usd) }
       let(:comp3) { Exchange::Currency.new(50, :eur) }
       let(:comp4) { Exchange::Currency.new(45, :eur) }
-      let(:comp5) { Exchange::Currency.new(66.1, :usd) }
+      let(:comp5) { Exchange::Currency.new(50, :eur).to_usd }
       let(:comp6) { Exchange::Currency.new(66.1, :usd, :at => Time.gm(2011,1,1)) }
       before(:each) do
         mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
@@ -167,35 +167,95 @@ describe "Exchange::Currency" do
     end
     describe "round" do
       subject { Exchange::Currency.new(40.123, :usd) }
-      it "should apply it to its number" do
-        subject.round.value.should == 40
-        subject.round.currency.should == :usd
-        subject.round.should be_kind_of Exchange::Currency
+      context "without arguments" do
+        it "should apply it to its number in the iso certified format" do
+          subject.round.value.should == 40.12
+          subject.round.currency.should == :usd
+          subject.round.should be_kind_of Exchange::Currency
+        end
+      end
+      context "with arguments" do
+        it "should apply it to its number" do
+          subject.round(0).value.should == 40
+          subject.round(0).currency.should == :usd
+          subject.round(0).should be_kind_of Exchange::Currency
+        end
+        it "should allow to round to whatever number of decimals" do
+          subject.round(2).value.should == 40.12
+          subject.round(2).currency.should == :usd
+          subject.round(2).should be_kind_of Exchange::Currency
+        end
       end
     end
     describe "ceil" do
-      subject { Exchange::Currency.new(40.123, :usd) }
-      it "should apply it to its number" do
-        subject.ceil.value.should == 41
-        subject.ceil.currency.should == :usd
-        subject.ceil.should be_kind_of Exchange::Currency
+      subject { Exchange::Currency.new(40.1236, :omr) }
+      context "without arguments" do
+        it "should apply it to its number in the iso certified format" do
+          subject.ceil.value.should == 40.124
+          subject.ceil.currency.should == :omr
+          subject.ceil.should be_kind_of Exchange::Currency
+        end
+      end
+      context "with arguments" do
+        it "should apply it to its number" do
+          subject.ceil(0).value.should == 41
+          subject.ceil(0).currency.should == :omr
+          subject.ceil(0).should be_kind_of Exchange::Currency
+        end
+        it "should allow to round to whatever number of decimals" do
+          subject.ceil(2).value.should == 40.13
+          subject.ceil(2).currency.should == :omr
+          subject.ceil(2).should be_kind_of Exchange::Currency
+        end
       end
     end
     describe "floor" do
-      subject { Exchange::Currency.new(40.723, :usd) }
-      it "should apply it to its number" do
-        subject.floor.value.should == 40
-        subject.floor.currency.should == :usd
-        subject.floor.should be_kind_of Exchange::Currency
+      subject { Exchange::Currency.new(40.723, :jpy) }
+      context "without arguments" do
+        it "should apply it to its number in the iso certified format" do
+          subject.floor.value.should == 40
+          subject.floor.currency.should == :jpy
+          subject.floor.should be_kind_of Exchange::Currency
+        end
+      end
+      context "with arguments" do
+        it "should apply it to its number" do
+          subject.floor(1).value.should == 40.7
+          subject.floor(1).currency.should == :jpy
+          subject.floor(1).should be_kind_of Exchange::Currency
+        end
+        it "should allow to round to whatever number of decimals" do
+          subject.floor(2).value.should == 40.72
+          subject.floor(2).currency.should == :jpy
+          subject.floor(2).should be_kind_of Exchange::Currency
+        end
       end
     end
   end
+  describe "to_s" do
+    it "should render the currency according to ISO 4217 Definitions" do
+      Exchange::Currency.new(23.232524, 'TND').to_s.should == "TND 23.233"
+      Exchange::Currency.new(23.23252423, 'SAR').to_s.should == "SAR 23.23"
+      Exchange::Currency.new(23.23252423, 'CLP').to_s.should == "CLP 23"
+      Exchange::Currency.new(23.2, 'TND').to_s.should == "TND 23.200"
+      Exchange::Currency.new(23.4, 'SAR').to_s.should == "SAR 23.40"
+      Exchange::Currency.new(23.0, 'CLP').to_s.should == "CLP 23"
+    end
+    it "should render only the currency amount if the argument amount is passed" do
+      Exchange::Currency.new(23.232524, 'TND').to_s(:amount).should == "23.233"
+      Exchange::Currency.new(23.23252423, 'SAR').to_s(:amount).should == "23.23"
+      Exchange::Currency.new(23.23252423, 'CLP').to_s(:amount).should == "23"
+      Exchange::Currency.new(23.2, 'TND').to_s(:amount).should == "23.200"
+      Exchange::Currency.new(23.4, 'SAR').to_s(:amount).should == "23.40"
+      Exchange::Currency.new(23.0, 'CLP').to_s(:amount).should == "23"
+    end
+  end
   describe "methods via method missing" do
     it "should be able to convert via to_currency to other currencies" do
       mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 6)
       {'chf' => 36.5, 'usd' => 40.0, 'dkk' => 225.12, 'sek' => 269.85, 'nok' => 232.06, 'rub' => 1205.24}.each do |currency, value|
         c = subject.send(:"to_#{currency}")
-        c.value.should == value
+        c.value.round(2).should == value
         c.currency.should == currency
       end
     end
@@ -203,7 +263,7 @@ describe "Exchange::Currency" do
       mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/historical/2011-10-09.json", fixture('api_responses/example_json_api.json'), 6)
       {'chf' => 36.5, 'usd' => 40.0, 'dkk' => 225.12, 'sek' => 269.85, 'nok' => 232.06, 'rub' => 1205.24}.each do |currency, value|
         c = subject.send(:"to_#{currency}", :at => Time.gm(2011,10,9))
-        c.value.should == value
+        c.value.round(2).should == value
         c.currency.should == currency
       end
     end
@@ -211,6 +271,9 @@ describe "Exchange::Currency" do
       mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/historical/2011-01-01.json", fixture('api_responses/example_json_api.json'), 2)
       5.eur(:at => Time.gm(2011,1,1)).to_usd.value.should == 5.eur.to_usd(:at => Time.gm(2011,1,1)).value
     end
+    it "should raise errors for currency conversions it does not have rates for" do
+      lambda { subject.to_ssp }.should raise_error(NoRateError)
+    end
     it "should pass on methods it does not understand to its number" do
       subject.to_f.should == 40
       lambda { subject.to_hell }.should raise_error(NoMethodError)

data/spec/exchange/external_api/base_spec.rb

@@ -3,29 +3,32 @@ require 'spec_helper'
 describe "Exchange::ExternalAPI::Base" do
   subject { Exchange::ExternalAPI::Base.new }
   before(:each) do
-    subject.instance_variable_set("@rates", {'EUR' => 3.45, 'CHF' => 5.565})
+    Exchange::Configuration.cache = false
+  end
+  before(:each) do
+    subject.instance_variable_set("@rates", {'EUR' => BigDecimal.new("3.45"), 'CHF' => BigDecimal.new("5.565")})
     subject.instance_variable_set("@base", 'usd')
   end
   describe "rate" do
     it "should put out an exchange rate for the two currencies" do
       subject.should_receive(:update).once
-      ((subject.rate('eur', 'chf') * 10000).round.to_f / 10000).should == 1.613
+      subject.rate('eur', 'chf').round(3).should == 1.613
     end
     it "should put out an exchange rate for the two currencies and pass on opts" do
       time = Time.now
       subject.should_receive(:update).with(:at => time).once
-      ((subject.rate('eur', 'chf', :at => time) * 10000).round.to_f / 10000).should == 1.613
+      subject.rate('eur', 'chf', :at => time).round(3).should == 1.613
     end
   end
   describe "convert" do
     it "should convert according to the given rates" do
       subject.should_receive(:update).once
-      subject.convert(80,'chf','eur').should == 49.6
+      subject.convert(80,'chf','eur').round(2).should == 49.6
     end
     it "should convert according to the given rates and pass opts" do
       time = Time.now
       subject.should_receive(:update).with(:at => time).once
-      subject.convert(80,'chf','eur', :at => time).should == 49.6
+      subject.convert(80,'chf','eur', :at => time).round(2).should == 49.6
     end
   end
 end

data/spec/exchange/external_api/call_spec.rb

@@ -7,27 +7,31 @@ describe "Exchange::ExternalAPI::Call" do
   describe "initialization" do
     context "with a json api" do
       before(:each) do
-        mock_api('JSON_API', fixture('api_responses/example_json_api.json'))
+        mock_api('JSON_API', fixture('api_responses/example_json_api.json'), 5)
       end
       it "should call the api and yield a block with the result" do
         Exchange::ExternalAPI::Call.new('JSON_API') do |result|
           result.should == JSON.load(fixture('api_responses/example_json_api.json'))
         end
       end
-      #context "with http errors" do
-        #let(:opened_uri) { mock('uri', :read => fixture('api_responses/example_xml_api.xml'))}
-        # it "should recall as many times as specified in the options" do
-        #   URI.should_receive(:parse).with('JSON_API').and_return(uri_mock)
-        #   Exchange::ExternalAPI::Call.new('JSON_API') do |result|
-        #     result.should == JSON.load(fixture('api_responses/example_json_api.json'))
-        #   end
-        # end
-        # it "should raise errors if the maximum call repetition is reached" do
-        #   URI.stub_chain :parse, :open, :read => OpenURI::HTTPError.new
-        #   uri_mock.should_receive(:open).at_most(5).times.and_raise(OpenURI::HTTPError)
-        #   lambda { Exchange::ExternalAPI::Call.new('JSON_API') }.should raise_error(Exchange::ExternalAPI::APIError)
-        # end
-      #end
+      context "with http errors" do
+        it "should recall and deliver the result if possible" do
+          @count = 0
+          @uri_mock.should_receive(:open).at_most(3).times.and_return do
+            @count += 1
+            @count == 3 ? mock('opened', :read => fixture('api_responses/example_json_api.json')) : raise(OpenURI::HTTPError.new('404', 'URI'))
+          end
+          Exchange::ExternalAPI::Call.new('JSON_API') do |result|
+            result.should == JSON.load(fixture('api_responses/example_json_api.json'))
+          end
+        end
+        it "should raise if the maximum recall size is reached" do
+          @uri_mock.should_receive(:open).at_most(5).times.and_return do
+            raise OpenURI::HTTPError.new('404', 'URI')
+          end
+          lambda { Exchange::ExternalAPI::Call.new('JSON_API') }.should raise_error(Exchange::ExternalAPI::APIError)
+        end
+      end
       context "with socket errors" do
         it "should raise an error immediately" do
           @uri_mock.should_receive(:open).at_most(5).times.and_raise(SocketError)
@@ -38,26 +42,31 @@ describe "Exchange::ExternalAPI::Call" do
   end
   context "with an xml api" do
     before(:each) do
-      mock_api('XML_API', fixture('api_responses/example_xml_api.xml'))
+      mock_api('XML_API', fixture('api_responses/example_xml_api.xml'), 5)
     end
     it "should call the api and yield a block with the result" do
       Exchange::ExternalAPI::Call.new('XML_API', :format => :xml) do |result|
         result.to_s.should == Nokogiri.parse(fixture('api_responses/example_xml_api.xml')).to_s
       end
     end
-    # context "with http errors" do
-    #   let(:error_mock) { mock('opened_uri') }
-    #   it "should recall as many times as specified in the options" do
-    #     URI.stub! :parse => OpenURI::HTTPError.new
-    #     Exchange::ExternalAPI::Call.new('XML_API', :format => :xml) do |result|
-    #       result.to_s.should == Nokogiri.parse(fixture('api_responses/example_xml_api.xml')).to_s
-    #     end
-    #   end
-    #   it "should raise errors if the maximum call repetition is reached" do
-    #     URI.stub! :parse => OpenURI::HTTPError.new
-    #     lambda { Exchange::ExternalAPI::Call.new('XML_API', :format => :xml) }.should raise_error(Exchange::ExternalAPI::APIError)
-    #   end
-    # end
+    context "with http errors" do
+      it "should recall and deliver the result if possible" do
+        @count = 0
+        @uri_mock.should_receive(:open).at_most(3).times.and_return do
+          @count += 1
+          @count == 3 ? mock('opened', :read => fixture('api_responses/example_xml_api.xml')) : raise(OpenURI::HTTPError.new('404', 'URI'))
+        end
+        Exchange::ExternalAPI::Call.new('XML_API', :format => :xml) do |result|
+          result.to_s.should == Nokogiri.parse(fixture('api_responses/example_xml_api.xml')).to_s
+        end
+      end
+      it "should raise if the maximum recall size is reached" do
+        @uri_mock.should_receive(:open).at_most(5).times.and_return do
+          raise OpenURI::HTTPError.new('404', 'URI')
+        end
+        lambda { Exchange::ExternalAPI::Call.new('XML_API') }.should raise_error(Exchange::ExternalAPI::APIError)
+      end
+    end
     context "with socket errors" do
       it "should raise an error immediately" do
         @uri_mock.should_receive(:open).once.and_raise(SocketError)