money 6.5.1 → 6.6.0

data/lib/money/currency.rb

@@ -16,10 +16,37 @@ class Money
     extend Money::Currency::Loader
     extend Money::Currency::Heuristics
 
+    # Keeping cached instances in sync between threads
+    @@mutex = Mutex.new
+
+    # Thrown when a Currency has been registered without all the attributes
+    # which are required for the current action.
+    class MissingAttributeError < StandardError
+      def initialize(method, currency, attribute)
+        super(
+          "Can't call Currency.#{method} - currency '#{currency}' is missing "\
+          "the attribute '#{attribute}'"
+        )
+      end
+    end
+
     # Thrown when an unknown currency is requested.
     class UnknownCurrency < ArgumentError; end
 
     class << self
+      alias_method :original_new, :new
+      def new(id)
+        id = id.to_s.downcase
+        unless stringified_keys.include?(id)
+          raise UnknownCurrency, "Unknown currency '#{id}'"
+        end
+
+        @@mutex.synchronize { instances[id] } || super
+      end
+
+      def instances
+        @instances ||= Hash.new { |h, k| h[k] = original_new(k) }
+      end
 
       # Lookup a currency with given +id+ an returns a +Currency+ instance on
       # success, +nil+ otherwise.
@@ -103,7 +130,13 @@ class Money
       #   Money::Currency.iso_codes()
       #   [#<Currency ..USD>, 'CAD', 'EUR']...
       def all
-        table.keys.map {|curr| Currency.new(curr)}.sort_by(&:priority)
+        table.keys.map do |curr|
+          c = Currency.new(curr)
+          if c.priority.nil?
+            raise MissingAttributeError.new(:all, c.id, :priority)
+          end
+          c
+        end.sort_by(&:priority)
       end
 
       # We need a string-based validator before creating an unbounded number of
@@ -135,6 +168,7 @@ class Money
       # @option delimiter [String] character between each thousands place
       def register(curr)
         key = curr.fetch(:iso_code).downcase.to_sym
+        @@mutex.synchronize { instances.delete(key.to_s) }
         @table[key] = curr
         @stringified_keys = stringify_keys
       end
@@ -171,40 +205,40 @@ class Money
       end
     end
 
-    # @!attribute [r] id 
+    # @!attribute [r] id
     #   @return [Symbol] The symbol used to identify the currency, usually THE
     #     lowercase +iso_code+ attribute.
-    # @!attribute [r] priority 
+    # @!attribute [r] priority
     #   @return [Integer] A numerical value you can use to sort/group the
     #     currency list.
-    # @!attribute [r] iso_code 
+    # @!attribute [r] iso_code
     #   @return [String] The international 3-letter code as defined by the ISO
     #     4217 standard.
-    # @!attribute [r] iso_numeric 
+    # @!attribute [r] iso_numeric
     #   @return [String] The international 3-numeric code as defined by the ISO
     #     4217 standard.
-    # @!attribute [r] name 
+    # @!attribute [r] name
     #   @return [String] The currency name.
-    # @!attribute [r] symbol 
+    # @!attribute [r] symbol
     #   @return [String] The currency symbol (UTF-8 encoded).
-    # @!attribute [r] disambiguate_symbol 
+    # @!attribute [r] disambiguate_symbol
     #   @return [String] Alternative currency used if symbol is ambiguous
-    # @!attribute [r] html_entity 
+    # @!attribute [r] html_entity
     #   @return [String] The html entity for the currency symbol
-    # @!attribute [r] subunit 
+    # @!attribute [r] subunit
     #   @return [String] The name of the fractional monetary unit.
-    # @!attribute [r] subunit_to_unit 
+    # @!attribute [r] subunit_to_unit
     #   @return [Integer] The proportion between the unit and the subunit
-    # @!attribute [r] decimal_mark 
+    # @!attribute [r] decimal_mark
     #   @return [String] The decimal mark, or character used to separate the
     #     whole unit from the subunit.
-    # @!attribute [r] The 
+    # @!attribute [r] The
     #   @return [String] character used to separate thousands grouping of the
     #     whole unit.
-    # @!attribute [r] symbol_first 
+    # @!attribute [r] symbol_first
     #   @return [Boolean] Should the currency symbol precede the amount, or
     #     should it come after?
-    # @!attribute [r] smallest_denomination 
+    # @!attribute [r] smallest_denomination
     #   @return [Integer] Smallest amount of cash possible (in the subunit of
     #     this currency)
 
@@ -214,6 +248,7 @@ class Money
 
     alias_method :separator, :decimal_mark
     alias_method :delimiter, :thousands_separator
+    alias_method :eql?, :==
 
     # Create a new +Currency+ object.
     #
@@ -225,10 +260,6 @@ class Money
     # @example
     #   Money::Currency.new(:usd) #=> #<Money::Currency id: usd ...>
     def initialize(id)
-      id = id.to_s.downcase
-      unless self.class.stringified_keys.include?(id)
-        raise UnknownCurrency, "Unknown currency '#{id}'"
-      end
       @id = id.to_sym
       initialize_data!
     end
@@ -283,22 +314,6 @@ class Money
     end
     private :compare_ids
 
-    # Compares +self+ with +other_currency+ and returns +true+ if the are the
-    # same or if their +id+ attributes match.
-    #
-    # @param [Money::Currency] other_currency The currency to compare to.
-    #
-    # @return [Boolean]
-    #
-    # @example
-    #   c1 = Money::Currency.new(:usd)
-    #   c2 = Money::Currency.new(:jpy)
-    #   c1.eql? c1 #=> true
-    #   c1.eql? c2 #=> false
-    def eql?(other_currency)
-      self == other_currency
-    end
-
     # Returns a Fixnum hash value based on the +id+ attribute in order to use
     # functions like & (intersection), group_by, etc.
     #

data/lib/money/money/arithmetic.rb

@@ -12,25 +12,27 @@ class Money
     end
 
     # Checks whether two money objects have the same currency and the same
-    # amount. Checks against money objects with a different currency and checks
-    # against objects that do not respond to #to_money will always return false.
+    # amount. If money objects have a different currency it will only be true
+    # if the amounts are both zero. Checks against objects that do not respond
+    # to #to_money, in which case, it will always return false.
     #
     # @param [Money] other_money Value to compare with.
     #
     # @return [Boolean]
     #
     # @example
-    #   Money.new(100) == Money.new(101) #=> false
-    #   Money.new(100) == Money.new(100) #=> true
-    def ==(other_money)
+    #   Money.new(100).eql?(Money.new(101))           #=> false
+    #   Money.new(100).eql?(Money.new(100))           #=> true
+    #   Money.new(0, "USD").eql?(Money.new(0, "EUR")) #=> true
+    def eql?(other_money)
       if other_money.respond_to?(:to_money)
         other_money = other_money.to_money
-        fractional == other_money.fractional && currency == other_money.currency
+        (fractional == other_money.fractional && currency == other_money.currency) ||
+          (fractional == 0 && other_money.fractional == 0)
       else
         false
       end
     end
-    alias_method :eql?, :==
 
     def <=>(val)
       if val.respond_to?(:to_money)
@@ -39,8 +41,6 @@ class Money
           val = val.exchange_to(currency)
         end
         fractional <=> val.fractional
-      else
-        raise ArgumentError, "Comparison of #{self.class} with #{val.inspect} failed"
       end
     end
 

data/lib/money/money/formatting.rb

@@ -15,7 +15,7 @@ class Money
         if self.class.use_i18n
           begin
             I18n.t name, :scope => "number.currency.format", :raise => true
-          rescue I18n::MissingTranslationData => e
+          rescue I18n::MissingTranslationData
             I18n.t name, :scope =>"number.format", :default => (currency.send(method) || character)
           end
         else
@@ -184,24 +184,36 @@ class Money
     #  due to equal symbols for different currencies. Uses the `disambiguate_symbol`.
     #
     # @example
-    #   Money.new(100, "USD").format(:disambiguate => false)   #=> "$100.00"
-    #   Money.new(100, "CAD").format(:disambiguate => false)   #=> "$100.00"
-    #   Money.new(100, "USD").format(:disambiguate => true)    #=> "$100.00"
-    #   Money.new(100, "CAD").format(:disambiguate => true)    #=> "C$100.00"
+    #   Money.new(10000, "USD").format(:disambiguate => false)   #=> "$100.00"
+    #   Money.new(10000, "CAD").format(:disambiguate => false)   #=> "$100.00"
+    #   Money.new(10000, "USD").format(:disambiguate => true)    #=> "$100.00"
+    #   Money.new(10000, "CAD").format(:disambiguate => true)    #=> "C$100.00"
     #
     # @option *rules [Boolean] :html_wrap_symbol (false) Wraps the currency symbol
     #  in a html <span> tag.
     #
     # @example
-    #   Money.new(100, "USD").format(:disambiguate => false)
+    #   Money.new(10000, "USD").format(:disambiguate => false)
     #   #=> "<span class=\"currency_symbol\">$100.00</span>
     #
     # @option *rules [Symbol] :symbol_position (:before) `:before` if the currency
     #   symbol goes before the amount, `:after` if it goes after.
     #
     # @example
-    #   Money.new(100, "USD").format(:symbol_position => :before) #=> "$100.00"
-    #   Money.new(100, "USD").format(:symbol_position => :after)  #=> "100.00 $"
+    #   Money.new(10000, "USD").format(:symbol_position => :before) #=> "$100.00"
+    #   Money.new(10000, "USD").format(:symbol_position => :after)  #=> "100.00 $"
+    #
+    # @option *rules [Boolean] :translate (true) `true` Checks for custom
+    #   symbol definitions using I18n.
+    #
+    # @example
+    #   # With the following entry in the translation files:
+    #   # en:
+    #   #   number:
+    #   #     currency:
+    #   #       symbol:
+    #   #         CAD: "CAD$"
+    #   Money.new(10000, "CAD").format(:translate => true) #=> "CAD$100.00"
     #
     # Note that the default rules can be defined through +Money.default_formatting_rules+ hash.
     #
@@ -212,6 +224,7 @@ class Money
 
       rules = default_formatting_rules.merge(rules)
       rules = localize_formatting_rules(rules)
+      rules = translate_formatting_rules(rules) if rules[:translate]
 
       if fractional == 0
         if rules[:display_free].respond_to?(:to_str)
@@ -343,6 +356,15 @@ class Money
     end
   end
 
+  def translate_formatting_rules(rules)
+    begin
+      rules[:symbol] = I18n.t currency.iso_code, :scope => "number.currency.symbol", :raise => true
+    rescue I18n::MissingTranslationData
+      # Do nothing
+    end
+    rules
+  end
+
   def localize_formatting_rules(rules)
     if currency.iso_code == "JPY" && I18n.locale == :ja
       rules[:symbol] = "円" unless rules[:symbol] == false

data/lib/money/money.rb

@@ -15,7 +15,7 @@ require "money/money/formatting"
 #
 # @see http://en.wikipedia.org/wiki/Money
 class Money
-  include Money::Arithmetic, Money::Formatting, Comparable
+  include Comparable, Money::Arithmetic, Money::Formatting
   extend Constructors
 
   # Raised when smallest denomination of a currency is not defined
@@ -94,12 +94,6 @@ class Money
     #     this property is an instance of +Bank::VariableExchange.+ It allows
     #     one to specify custom exchange rates.
     #
-    # @!attribute default_currency
-    #   @return [Money::Currency] The default currency, which is used when
-    #     +Money.new+ is called without an explicit currency argument. The
-    #     default value is Currency.new("USD"). The value must be a valid
-    #     +Money::Currency+ instance.
-    #
     # @!attribute default_formatting_rules
     #   @return [Hash] Use this to define a default hash of rules for everytime
     #     +Money#format+ is called.  Rules provided on method call will be
@@ -123,11 +117,17 @@ class Money
     # @!attribute [rw] conversion_precision
     #   @return [Fixnum] Use this to specify precision for converting Rational
     #     to BigDecimal
-    attr_accessor :default_bank, :default_currency, :default_formatting_rules,
+    attr_accessor :default_bank, :default_formatting_rules,
       :use_i18n, :infinite_precision, :conversion_precision
 
     # @attr_writer rounding_mode Use this to specify the rounding mode
-    attr_writer :rounding_mode
+    #
+    # @!attribute default_currency
+    #   @return [Money::Currency] The default currency, which is used when
+    #     +Money.new+ is called without an explicit currency argument. The
+    #     default value is Currency.new("USD"). The value must be a valid
+    #     +Money::Currency+ instance.
+    attr_writer :rounding_mode, :default_currency
 
   end
 
@@ -211,13 +211,35 @@ class Money
     self.default_bank = Bank::SingleCurrency.instance
   end
 
+  # Creates a new Money object of value given in the +unit+ of the given
+  # +currency+.
+  #
+  # @param [Numeric] amount The numerical value of the money.
+  # @param [Currency, String, Symbol] currency The currency format.
+  # @param [Money::Bank::*] bank The exchange bank to use.
+  #
+  # @example
+  #   Money.from_amount(23.45, "USD") # => #<Money fractional:2345 currency:USD>
+  #   Money.from_amount(23.45, "JPY") # => #<Money fractional:23 currency:JPY>
+  #
+  # @return [Money]
+  #
+  # @see #initialize
+  def self.from_amount(amount, currency = default_currency, bank = default_bank)
+    Numeric === amount or raise ArgumentError, "'amount' must be numeric"
+    currency = Currency.wrap(currency)
+    value = amount.to_d * currency.subunit_to_unit
+    value = value.round(0, rounding_mode) unless infinite_precision
+    new(value, currency, bank)
+  end
+
   # Creates a new Money object of value given in the
   # +fractional unit+ of the given +currency+.
   #
   # Alternatively you can use the convenience
   # methods like {Money.ca_dollar} and {Money.us_dollar}.
   #
-  # @param [Object] obj Either The fractional value of the money,
+  # @param [Object] obj Either the fractional value of the money,
   #   a Money object, or a currency. (If passed a currency as the first
   #   argument, a Money will be created in that currency with fractional value
   #   = 0.

data/lib/money/rates_store/memory.rb

@@ -0,0 +1,120 @@
+class Money
+  module RatesStore
+
+    # Class for thread-safe storage of exchange rate pairs.
+    # Used by instances of +Money::Bank::VariableExchange+.
+    #
+    # @example
+    #   store = Money::RatesStore::Memory.new
+    #   store.add_rate 'USD', 'CAD', 0.98
+    #   store.get_rate 'USD', 'CAD' # => 0.98
+    #   # iterates rates
+    #   store.each_rate {|iso_from, iso_to, rate| puts "#{from} -> #{to}: #{rate}" }
+    class Memory
+      INDEX_KEY_SEPARATOR = '_TO_'.freeze
+
+      # Initializes a new +Money::RatesStore::Memory+ object.
+      #
+      # @param [Hash] opts Optional store options.
+      # @option opts [Boolean] :without_mutex disables the usage of a mutex
+      # @param [Hash] rt Optional initial exchange rate data.
+      def initialize(opts = {}, rt = {})
+        @options, @index = opts, rt
+        @mutex = Mutex.new
+        @in_transaction = false
+      end
+
+      # Registers a conversion rate and returns it. Uses +Mutex+ to synchronize data access.
+      #
+      # @param [String] currency_iso_from Currency to exchange from.
+      # @param [String] currency_iso_to Currency to exchange to.
+      # @param [Numeric] rate Rate to use when exchanging currencies.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   store = Money::RatesStore::Memory.new
+      #   store.add_rate("USD", "CAD", 1.24515)
+      #   store.add_rate("CAD", "USD", 0.803115)
+      def add_rate(currency_iso_from, currency_iso_to, rate)
+        transaction { index[rate_key_for(currency_iso_from, currency_iso_to)] = rate }
+      end
+
+      # Retrieve the rate for the given currencies. Uses +Mutex+ to synchronize data access.
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @param [String] currency_iso_from Currency to exchange from.
+      # @param [String] currency_iso_to Currency to exchange to.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   store = Money::RatesStore::Memory.new
+      #   store.add_rate("USD", "CAD", 1.24515)
+      #
+      #   store.get_rate("USD", "CAD") #=> 1.24515
+      def get_rate(currency_iso_from, currency_iso_to)
+        transaction { index[rate_key_for(currency_iso_from, currency_iso_to)] }
+      end
+
+      def marshal_dump
+        [self.class, index, options]
+      end
+
+
+      # Wraps block execution in a thread-safe transaction
+      def transaction(&block)
+        if @in_transaction || options[:without_mutex]
+          block.call self
+        else
+          @mutex.synchronize do
+            @in_transaction = true
+            result = block.call
+            @in_transaction = false
+            result
+          end
+        end
+      end
+
+      # Iterate over rate tuples (iso_from, iso_to, rate)
+      #
+      # @yieldparam iso_from [String] Currency ISO string.
+      # @yieldparam iso_to [String] Currency ISO string.
+      # @yieldparam rate [Numeric] Exchange rate.
+      #
+      # @return [Enumerator]
+      #
+      # @example
+      #   store.each_rate do |iso_from, iso_to, rate|
+      #     puts [iso_from, iso_to, rate].join
+      #   end
+      def each_rate(&block)
+        enum = Enumerator.new do |yielder|
+          index.each do |key, rate|
+            iso_from, iso_to = key.split(INDEX_KEY_SEPARATOR)
+            yielder.yield iso_from, iso_to, rate                  
+          end
+        end
+
+        block_given? ? enum.each(&block) : enum
+      end
+
+      private
+
+      attr_reader :index, :options
+
+      # Return the rate hashkey for the given currencies.
+      #
+      # @param [String] currency_iso_from The currency to exchange from.
+      # @param [String] currency_iso_to The currency to exchange to.
+      #
+      # @return [String]
+      #
+      # @example
+      #   rate_key_for("USD", "CAD") #=> "USD_TO_CAD"
+      def rate_key_for(currency_iso_from, currency_iso_to)
+        [currency_iso_from, currency_iso_to].join(INDEX_KEY_SEPARATOR).upcase
+      end
+    end
+  end
+end

data/lib/money/version.rb

@@ -1,3 +1,3 @@
 class Money
-  VERSION = "6.5.1"
+  VERSION = "6.6.0"
 end

data/money.gemspec

@@ -29,7 +29,7 @@ MSG
 
   s.add_development_dependency "bundler", "~> 1.3"
   s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", "~> 3.0.0"
+  s.add_development_dependency "rspec", "~> 3.2.0"
   s.add_development_dependency "yard", "~> 0.8"
   s.add_development_dependency "kramdown", "~> 1.1"
 

data/spec/bank/base_spec.rb

@@ -1,77 +1,81 @@
 require 'spec_helper'
 
-describe Money::Bank::Base do
+class Money
+  module Bank
+    describe Base do
 
-  describe ".instance" do
-    it "is local to one class" do
-      klass = Money::Bank::Base
-      subclass = Class.new(Money::Bank::Base)
-      expect(klass.instance).not_to eq subclass.instance
-    end
-  end
+      describe ".instance" do
+        it "is local to one class" do
+          klass = Base
+          subclass = Class.new(Base)
+          expect(klass.instance).not_to eq subclass.instance
+        end
+      end
 
-  describe "#initialize" do
-    it "accepts a block and stores @rounding_method" do
-      proc = Proc.new { |n| n.ceil }
-      bank = Money::Bank::Base.new(&proc)
-      expect(bank.rounding_method).to eq proc
-    end
-  end
+      describe "#initialize" do
+        it "accepts a block and stores @rounding_method" do
+          proc = Proc.new { |n| n.ceil }
+          bank = Base.new(&proc)
+          expect(bank.rounding_method).to eq proc
+        end
+      end
 
-  describe "#setup" do
-    it "calls #setup after #initialize" do
-      class MyBank < Money::Bank::Base
-        attr_reader :setup_called
+      describe "#setup" do
+        it "calls #setup after #initialize" do
+          class MyBank < Base
+            attr_reader :setup_called
 
-        def setup
-          @setup_called = true
+            def setup
+              @setup_called = true
+            end
+          end
+
+          bank = MyBank.new
+          expect(bank.setup_called).to eq true
         end
       end
 
-      bank = MyBank.new
-      expect(bank.setup_called).to eq true
-    end
-  end
-
-  describe "#exchange_with" do
-    it "is not implemented" do
-      expect { subject.exchange_with(Money.new(100, 'USD'), 'EUR') }.to raise_exception(NotImplementedError)
-    end
-  end
+      describe "#exchange_with" do
+        it "is not implemented" do
+          expect { subject.exchange_with(Money.new(100, 'USD'), 'EUR') }.to raise_exception(NotImplementedError)
+        end
+      end
 
-  describe "#same_currency?" do
-    it "accepts str/str" do
-      expect { subject.send(:same_currency?, 'USD', 'EUR') }.to_not raise_exception
-    end
+      describe "#same_currency?" do
+        it "accepts str/str" do
+          expect { subject.send(:same_currency?, 'USD', 'EUR') }.to_not raise_exception
+        end
 
-    it "accepts currency/str" do
-      expect { subject.send(:same_currency?, Money::Currency.wrap('USD'), 'EUR') }.to_not raise_exception
-    end
+        it "accepts currency/str" do
+          expect { subject.send(:same_currency?, Currency.wrap('USD'), 'EUR') }.to_not raise_exception
+        end
 
-    it "accepts str/currency" do
-      expect { subject.send(:same_currency?, 'USD', Money::Currency.wrap('EUR')) }.to_not raise_exception
-    end
+        it "accepts str/currency" do
+          expect { subject.send(:same_currency?, 'USD', Currency.wrap('EUR')) }.to_not raise_exception
+        end
 
-    it "accepts currency/currency" do
-      expect { subject.send(:same_currency?, Money::Currency.wrap('USD'), Money::Currency.wrap('EUR')) }.to_not raise_exception
-    end
+        it "accepts currency/currency" do
+          expect { subject.send(:same_currency?, Currency.wrap('USD'), Currency.wrap('EUR')) }.to_not raise_exception
+        end
 
-    it "returns true when currencies match" do
-      expect(subject.send(:same_currency?, 'USD', 'USD')).to be true
-      expect(subject.send(:same_currency?, Money::Currency.wrap('USD'), 'USD')).to be true
-      expect(subject.send(:same_currency?, 'USD', Money::Currency.wrap('USD'))).to be true
-      expect(subject.send(:same_currency?, Money::Currency.wrap('USD'), Money::Currency.wrap('USD'))).to be true
-    end
+        it "returns true when currencies match" do
+          expect(subject.send(:same_currency?, 'USD', 'USD')).to be true
+          expect(subject.send(:same_currency?, Currency.wrap('USD'), 'USD')).to be true
+          expect(subject.send(:same_currency?, 'USD', Currency.wrap('USD'))).to be true
+          expect(subject.send(:same_currency?, Currency.wrap('USD'), Currency.wrap('USD'))).to be true
+        end
 
-    it "returns false when currencies do not match" do
-      expect(subject.send(:same_currency?, 'USD', 'EUR')).to be false
-      expect(subject.send(:same_currency?, Money::Currency.wrap('USD'), 'EUR')).to be false
-      expect(subject.send(:same_currency?, 'USD', Money::Currency.wrap('EUR'))).to be false
-      expect(subject.send(:same_currency?, Money::Currency.wrap('USD'), Money::Currency.wrap('EUR'))).to be false
-    end
+        it "returns false when currencies do not match" do
+          expect(subject.send(:same_currency?, 'USD', 'EUR')).to be false
+          expect(subject.send(:same_currency?, Currency.wrap('USD'), 'EUR')).to be false
+          expect(subject.send(:same_currency?, 'USD', Currency.wrap('EUR'))).to be false
+          expect(subject.send(:same_currency?, Currency.wrap('USD'), Currency.wrap('EUR'))).to be false
+        end
 
-    it "raises an UnknownCurrency exception when an unknown currency is passed" do
-      expect { subject.send(:same_currency?, 'AAA', 'BBB') }.to raise_exception(Money::Currency::UnknownCurrency)
+        it "raises an UnknownCurrency exception when an unknown currency is passed" do
+          expect { subject.send(:same_currency?, 'AAA', 'BBB') }.to raise_exception(Currency::UnknownCurrency)
+        end
+      end
     end
   end
 end

data/spec/bank/single_currency_spec.rb

@@ -1,11 +1,15 @@
 require 'spec_helper'
 
-describe Money::Bank::SingleCurrency do
-  describe "#exchange_with" do
-    it "raises when called" do
-      expect {
-        subject.exchange_with(Money.new(100, 'USD'), 'EUR')
-      }.to raise_exception(Money::Bank::DifferentCurrencyError, "No exchanging of currencies allowed: 1.00 USD to EUR")
+class Money
+  module Bank
+    describe SingleCurrency do
+      describe "#exchange_with" do
+        it "raises when called" do
+          expect {
+            subject.exchange_with(Money.new(100, 'USD'), 'EUR')
+          }.to raise_exception(DifferentCurrencyError, "No exchanging of currencies allowed: 1.00 USD to EUR")
+        end
+      end
     end
   end
 end