exchange 0.2.6

data/spec/exchange/cache/rails_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe "Exchange::Cache::Rails" do
+  context "with rails defined" do
+    class ::Rails
+    end
+  end
+  subject { Exchange::Cache::Rails }
+  before(:each) do
+    Exchange::Configuration.define do |c|
+      c.cache      = :rails
+    end
+  end
+  after(:each) do
+    Exchange::Configuration.define do |c|
+      c.cache      = :memcached
+    end
+  end
+  describe "client" do
+    let(:client) { mock('rails_cache') }
+    it "should set up a client on the specified host and port for the cache" do
+      ::Rails.should_receive(:cache).and_return(client)
+      subject.client.should == client
+    end
+  end
+  describe "cached" do
+    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')
+          ::Rails.should_receive(:cache).and_return(client)
+          client.should_receive(:fetch).with('KEY', :expires_in => 86400).and_return "{\"RESULT\":\"YAY\"}"
+        end
+        it "should return the JSON loaded result" do
+          subject.cached('API_CLASS') { 'something' }.should == "{\"RESULT\":\"YAY\"}"
+        end
+      end
+      context "with an hourly cache" do
+        before(:each) do
+          Exchange::Configuration.update = :hourly
+          subject.should_receive(:key).with('API_CLASS', nil).and_return('KEY')
+          ::Rails.should_receive(:cache).and_return(client)
+          client.should_receive(:fetch).with('KEY', :expires_in => 3600).and_return "{\"RESULT\":\"YAY\"}"
+        end
+        after(:each) do
+          Exchange::Configuration.update = :daily
+        end
+        it "should return the JSON loaded result" do
+          subject.cached('API_CLASS') { 'something' }.should == "{\"RESULT\":\"YAY\"}"
+        end
+      end
+    end
+    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')
+        ::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
+      end
+      it "should call the block and delete the key to avoid empty caches" do
+        subject.cached('API_CLASS') { {'RESULT' => 'YAY'} }.should be_nil
+      end
+    end
+  end
+end

data/spec/exchange/cache/redis_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe "Exchange::Cache::Redis" do
+  subject { Exchange::Cache::Redis }
+  before(:each) do
+    Exchange::Configuration.define do |c|
+      c.cache      = :redis
+      c.cache_host = 'HOST'
+      c.cache_port = 'PORT'
+    end
+  end
+  after(:each) do
+    Exchange::Configuration.define do |c|
+      c.cache      = :memcached
+      c.cache_host = 'localhost'
+      c.cache_port = 11211
+    end
+  end
+  describe "client" do
+    let(:client) { mock('redis') }
+    after(:each) do
+      subject.send(:remove_class_variable, "@@client")
+    end
+    it "should set up a client on the specified host and port for the cache" do
+      ::Redis.should_receive(:new).with(:host => 'HOST', :port => 'PORT').and_return(client)
+      subject.client.should == client
+    end
+  end
+  describe "cached" do
+    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')
+        ::Redis.should_receive(:new).with(:host => 'HOST', :port => 'PORT').and_return(client)
+        client.should_receive(:get).with('KEY').and_return "{\"RESULT\":\"YAY\"}"
+      end
+      after(:each) do
+        subject.send(:remove_class_variable, "@@client")
+      end
+      it "should return the JSON loaded result" do
+        subject.cached('API_CLASS') { 'something' }.should == {'RESULT' => 'YAY'}
+      end
+    end
+    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')
+        ::Redis.should_receive(:new).with(:host => 'HOST', :port => 'PORT').and_return(client)
+        client.should_receive(:get).with('KEY').and_return nil
+      end
+      after(:each) do
+        subject.send(:remove_class_variable, "@@client")
+      end
+      context "with daily cache" do
+        it "should call the block and set and return the result" do
+          client.should_receive(:set).with('KEY', "{\"RESULT\":\"YAY\"}").once
+          client.should_receive(:expire).with('KEY', 86400).once
+          subject.cached('API_CLASS') { {'RESULT' => 'YAY'} }.should == {'RESULT' => 'YAY'}
+        end
+      end
+      context "with hourly cache" do
+        before(:each) do
+          Exchange::Configuration.update = :hourly
+        end
+        after(:each) do
+          Exchange::Configuration.update = :daily
+        end
+        it "should call the block and set and return the result" do
+          client.should_receive(:set).with('KEY', "{\"RESULT\":\"YAY\"}").once
+          client.should_receive(:expire).with('KEY', 3600).once
+          subject.cached('API_CLASS') { {'RESULT' => 'YAY'} }.should == {'RESULT' => 'YAY'}
+        end
+      end
+    end
+  end
+end

data/spec/exchange/configuration_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Exchange::Configuration" do
+  let(:subject) { Exchange::Configuration }
+  it "should have a standard configuration" do
+    subject.api.should == :currency_bot
+    subject.api_class.should == Exchange::ExternalAPI::CurrencyBot
+    subject.cache.should == :memcached
+    subject.cache_class.should == Exchange::Cache::Memcached
+    subject.cache_host.should == 'localhost'
+    subject.cache_port.should == 11211
+    subject.retries.should == 5
+  end
+  it "should respond to all configuration getters and setters" do
+    [:api, :retries, :allow_mixed_operations, :cache, :cache_host, :cache_port, :update].each do |k|
+      subject.should be_respond_to(k)
+      subject.should be_respond_to(:"#{k}=")
+    end
+  end
+  it "should allow to be defined with a block" do
+    subject.define do |c|
+      c.api = :xavier_media
+      c.cache = :redis
+      c.retries = 60
+    end
+    subject.api.should == :xavier_media
+    subject.api_class.should == Exchange::ExternalAPI::XavierMedia
+    subject.cache.should == :redis
+    subject.cache_class.should == Exchange::Cache::Redis
+    subject.retries.should == 60
+  end
+  it "should allow to be set directly" do
+    subject.api = :paypal
+    subject.cache = :yml
+    subject.retries = 1
+    subject.api.should == :paypal
+    subject.cache.should == :yml
+    subject.retries.should == 1
+  end
+  after(:all) do
+    subject.api = :currency_bot
+    subject.cache = :memcached
+    subject.cache_host = 'localhost'
+    subject.cache_port = 11211
+    subject.retries = 5
+  end  
+end

data/spec/exchange/currency_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe "Exchange::Currency" do
+  subject { Exchange::Currency.new(40, :usd) }
+  before(:all) do
+    Exchange::Configuration.define do |c|
+      c.api = :currency_bot
+      c.cache = false
+    end
+  end
+  after(:all) do
+    Exchange::Configuration.cache = :memcached
+  end
+  it "should initialize with a number and a currency" do
+    subject.value.should == 40
+    subject.currency.should == :usd
+  end
+  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).currency.should == :chf
+      subject.convert_to(:chf).should be_kind_of Exchange::Currency
+    end
+  end
+  describe "operations" do
+    describe "+ other" do
+      it "should be able to add an integer" do
+        (subject + 40).value.should == 80
+      end
+      it "should be able to add a float" do
+        (subject + 40.5).value.should == 80.5
+      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, :sek)).currency.should == :usd
+      end
+      it "should raise when currencies get mixed and the configuration does not allow it" do
+        Exchange::Configuration.allow_mixed_operations = false
+        lambda { subject + Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+        Exchange::Configuration.allow_mixed_operations = true
+      end
+      it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
+        Exchange::Configuration.allow_mixed_operations = false
+        mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
+        lambda { subject + Exchange::Currency.new(30, :usd) }.should_not raise_error
+        Exchange::Configuration.allow_mixed_operations = true
+      end
+    end
+    describe "- other" do
+      it "should be able to subtract an integer" do
+        (subject + 40).value.should == 80
+      end
+      it "should be able to subtract a float" do
+        (subject + 40.5).value.should == 80.5
+      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(23.3, :eur)).currency.should == :usd
+      end
+      it "should raise when currencies get mixed and the configuration does not allow it" do
+        Exchange::Configuration.allow_mixed_operations = false
+        lambda { subject - Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+        Exchange::Configuration.allow_mixed_operations = true
+      end
+      it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
+        Exchange::Configuration.allow_mixed_operations = false
+        mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
+        lambda { subject - Exchange::Currency.new(30, :usd) }.should_not raise_error
+        Exchange::Configuration.allow_mixed_operations = true
+      end
+    end
+    describe "* other" do
+      it "should be able to multiply by an integer" do
+        (subject * 40).value.should == 1600
+      end
+      it "should be able to multiply a float" do
+        (subject * 40.5).value.should == 1620
+      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(23.3, :eur)).currency.should == :usd
+      end
+      it "should raise when currencies get mixed and the configuration does not allow it" do
+        Exchange::Configuration.allow_mixed_operations = false
+        lambda { subject * Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+        Exchange::Configuration.allow_mixed_operations = true
+      end
+      it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
+        Exchange::Configuration.allow_mixed_operations = false
+        mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
+        lambda { subject * Exchange::Currency.new(30, :usd) }.should_not raise_error
+        Exchange::Configuration.allow_mixed_operations = true
+      end
+    end
+    describe "/ other" do
+      it "should be able to multiply by an integer" 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
+      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(23.3, :eur)).currency.should == :usd
+      end
+      it "should raise when currencies get mixed and the configuration does not allow it" do
+        Exchange::Configuration.allow_mixed_operations = false
+        lambda { subject / Exchange::Currency.new(30, :chf) }.should raise_error(Exchange::CurrencyMixError)
+        Exchange::Configuration.allow_mixed_operations = true
+      end
+      it "should not raise when currencies get mixed and the configuration does not allow if the other currency is the same" do
+        Exchange::Configuration.allow_mixed_operations = false
+        mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 2)
+        lambda { subject / Exchange::Currency.new(30, :usd) }.should_not raise_error
+        Exchange::Configuration.allow_mixed_operations = true
+      end
+    end
+    describe "comparison" do
+      subject { Exchange::Currency.new(40.123, :usd) }
+      let(:comp1) { Exchange::Currency.new(40.123, :usd) }
+      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(: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)
+      end
+      context "with identical currencies" do
+        it "should be true if the currency and the value is the same" do
+          (subject == comp1).should be_true
+        end
+        it "should be false if the value is different" do
+          (subject == comp2).should be_false
+        end
+      end
+      context "with different currencies" do
+        it "should be true if the converted value is the same" do
+          (comp3 == comp5).should be_true
+        end
+        it "should be false if the converted value is different" do
+          (subject == comp4).should be_false
+        end
+        it "should be false if the currency is defined historic and the converted value is different" do
+          mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/historical/2011-01-01.json", fixture('api_responses/example_historic_json.json'), 2)
+          (comp3 == comp6).should be_false
+        end
+      end
+    end
+    describe "sorting" do
+      subject { Exchange::Currency.new(40.123, :usd) }
+      let(:comp1) { Exchange::Currency.new(40.123, :usd) }
+      let(:comp2) { Exchange::Currency.new(40, :usd) }
+      let(:comp3) { Exchange::Currency.new(50, :eur) }
+      let(:comp4) { Exchange::Currency.new(45, :eur) }
+      before(:each) do
+        mock_api("https://raw.github.com/currencybot/open-exchange-rates/master/latest.json", fixture('api_responses/example_json_api.json'), 6)
+      end
+      it "should sort and by doing conversions" do
+        [subject, comp1, comp2, comp3, comp4].sort.should == [comp2, subject, comp1, comp4, comp3]
+      end
+    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
+      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
+      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
+      end
+    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.currency.should == currency
+      end
+    end
+    it "should be able to convert via to_currency to other currencies and use historic data" 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.currency.should == currency
+      end
+    end
+    it "should use the own time if defined as historic to convert" 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 pass on methods it does not understand to its number" do
+      subject.to_f.should == 40
+      lambda { subject.to_hell }.should raise_error(NoMethodError)
+    end
+  end
+end

data/spec/exchange/external_api/base_spec.rb

@@ -0,0 +1,31 @@
+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})
+    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
+    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
+    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
+    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
+    end
+  end
+end

data/spec/exchange/external_api/call_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe "Exchange::ExternalAPI::Call" do
+  before(:all) do
+    Exchange::Configuration.cache = false
+  end
+  describe "initialization" do
+    context "with a json api" do
+      before(:each) do
+        mock_api('JSON_API', fixture('api_responses/example_json_api.json'))
+      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 socket errors" do
+        it "should raise an error immediately" do
+          @uri_mock.should_receive(:open).at_most(5).times.and_raise(SocketError)
+          lambda { Exchange::ExternalAPI::Call.new('JSON_API') }.should raise_error(Exchange::ExternalAPI::APIError)
+        end
+      end
+    end
+  end
+  context "with an xml api" do
+    before(:each) do
+      mock_api('XML_API', fixture('api_responses/example_xml_api.xml'))
+    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 socket errors" do
+      it "should raise an error immediately" do
+        @uri_mock.should_receive(:open).once.and_raise(SocketError)
+        lambda { Exchange::ExternalAPI::Call.new('XML_API', :format => :xml) }.should raise_error(Exchange::ExternalAPI::APIError)
+      end
+    end
+  end
+end