money 6.5.1 → 6.6.0

data/spec/currency_spec.rb

@@ -2,320 +2,352 @@
 
 require "spec_helper"
 
-describe Money::Currency do
+class Money
+  describe Currency do
 
-  FOO = '{ "priority": 1, "iso_code": "FOO", "iso_numeric": "840", "name": "United States Dollar", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 450, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": ",", "smallest_denomination": 1 }'
+    FOO = '{ "priority": 1, "iso_code": "FOO", "iso_numeric": "840", "name": "United States Dollar", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 450, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": ",", "smallest_denomination": 1 }'
 
-  def register_foo
-    Money::Currency.register(JSON.parse(FOO, :symbolize_names => true))
-  end
+    def register_foo(opts={})
+      foo_attrs = JSON.parse(FOO, :symbolize_names => true)
+      # Pass an array of attribute names to 'skip' to remove them from the 'FOO'
+      # json before registering foo as a currency.
+      Array(opts[:skip]).each { |attr| foo_attrs.delete(attr) }
+      Money::Currency.register(foo_attrs)
+    end
 
-  def unregister_foo
-    Money::Currency.unregister(JSON.parse(FOO, :symbolize_names => true))
-  end
+    def unregister_foo
+      Currency.unregister(JSON.parse(FOO, :symbolize_names => true))
+    end
 
-  describe "UnknownMoney::Currency" do
-    it "is a subclass of ArgumentError" do
-      expect(Money::Currency::UnknownCurrency < ArgumentError).to be true
+    describe "UnknownCurrency" do
+      it "is a subclass of ArgumentError" do
+        expect(Currency::UnknownCurrency < ArgumentError).to be true
+      end
     end
-  end
 
-  describe ".find" do
-    before { register_foo }
-    after  { unregister_foo }
+    describe ".find" do
+      before { register_foo }
+      after  { unregister_foo }
 
-    it "returns currency matching given id" do
-      expected = Money::Currency.new(:foo)
-      expect(Money::Currency.find(:foo)).to eq  expected
-      expect(Money::Currency.find(:FOO)).to eq  expected
-      expect(Money::Currency.find("foo")).to eq expected
-      expect(Money::Currency.find("FOO")).to eq expected
-    end
+      it "returns currency matching given id" do
+        expected = Currency.new(:foo)
+        expect(Currency.find(:foo)).to be  expected
+        expect(Currency.find(:FOO)).to be  expected
+        expect(Currency.find("foo")).to be expected
+        expect(Currency.find("FOO")).to be expected
+      end
 
-    it "returns nil unless currency matching given id" do
-      expect(Money::Currency.find("ZZZ")).to be_nil
+      it "returns nil unless currency matching given id" do
+        expect(Currency.find("ZZZ")).to be_nil
+      end
     end
-  end
 
-  describe ".find_by_iso_numeric" do
-    it "returns currency matching given numeric code" do
-      expect(Money::Currency.find_by_iso_numeric(978)).to eq          Money::Currency.new(:eur)
-      expect(Money::Currency.find_by_iso_numeric(208)).not_to eq      Money::Currency.new(:eur)
-      expect(Money::Currency.find_by_iso_numeric('840')).to eq        Money::Currency.new(:usd)
+    describe ".find_by_iso_numeric" do
+      it "returns currency matching given numeric code" do
+        expect(Currency.find_by_iso_numeric(978)).to eq     Currency.new(:eur)
+        expect(Currency.find_by_iso_numeric(208)).not_to eq Currency.new(:eur)
+        expect(Currency.find_by_iso_numeric('840')).to eq   Currency.new(:usd)
 
-      class Mock
-        def to_s
-          '208'
+        class Mock
+          def to_s
+            '208'
+          end
         end
+        expect(Currency.find_by_iso_numeric(Mock.new)).to eq     Currency.new(:dkk)
+        expect(Currency.find_by_iso_numeric(Mock.new)).not_to eq Currency.new(:usd)
       end
-      expect(Money::Currency.find_by_iso_numeric(Mock.new)).to eq     Money::Currency.new(:dkk)
-      expect(Money::Currency.find_by_iso_numeric(Mock.new)).not_to eq Money::Currency.new(:usd)
-    end
 
-    it "returns nil if no currency has the given numeric code" do
-      expect(Money::Currency.find_by_iso_numeric('non iso 4217 numeric code')).to be_nil
-      expect(Money::Currency.find_by_iso_numeric(0)).to be_nil
+      it "returns nil if no currency has the given numeric code" do
+        expect(Currency.find_by_iso_numeric('non iso 4217 numeric code')).to be_nil
+        expect(Currency.find_by_iso_numeric(0)).to be_nil
+      end
     end
-  end
 
-  describe ".wrap" do
-    it "returns nil if object is nil" do
-      expect(Money::Currency.wrap(nil)).to be_nil
-      expect(Money::Currency.wrap(Money::Currency.new(:usd))).to eq Money::Currency.new(:usd)
-      expect(Money::Currency.wrap(:usd)).to eq Money::Currency.new(:usd)
+    describe ".wrap" do
+      it "returns nil if object is nil" do
+        expect(Currency.wrap(nil)).to be_nil
+        expect(Currency.wrap(Currency.new(:usd))).to eq Currency.new(:usd)
+        expect(Currency.wrap(:usd)).to eq Currency.new(:usd)
+      end
     end
-  end
 
-  describe ".all" do
-    it "returns an array of currencies" do
-      expect(Money::Currency.all).to include Money::Currency.new(:usd)
-    end
-    it "includes registered currencies" do
-      register_foo
-      expect(Money::Currency.all).to include Money::Currency.new(:foo)
-      unregister_foo
-    end
-    it 'is sorted by priority' do
-      expect(Money::Currency.all.first.priority).to eq 1
+    describe ".all" do
+      it "returns an array of currencies" do
+        expect(Currency.all).to include Currency.new(:usd)
+      end
+      it "includes registered currencies" do
+        register_foo
+        expect(Currency.all).to include Currency.new(:foo)
+        unregister_foo
+      end
+      it 'is sorted by priority' do
+        expect(Currency.all.first.priority).to eq 1
+      end
+      it "raises a MissingAttributeError if any currency has no priority" do
+        register_foo(:skip => :priority)
+
+        expect{Money::Currency.all}.to \
+          raise_error(Money::Currency::MissingAttributeError, /foo.*priority/)
+        unregister_foo
+      end
     end
-  end
 
 
-  describe ".register" do
-    after { Money::Currency.unregister(iso_code: "XXX") if Money::Currency.find("XXX") }
-
-    it "registers a new currency" do
-      Money::Currency.register(
-        iso_code: "XXX",
-        name: "Golden Doubloon",
-        symbol: "%",
-        subunit_to_unit: 100
-      )
-      new_currency = Money::Currency.find("XXX")
-      expect(new_currency).not_to be_nil
-      expect(new_currency.name).to eq "Golden Doubloon"
-      expect(new_currency.symbol).to eq "%"
-    end
+    describe ".register" do
+      after { Currency.unregister(iso_code: "XXX") if Currency.find("XXX") }
+
+      it "registers a new currency" do
+        Currency.register(
+          iso_code: "XXX",
+          name: "Golden Doubloon",
+          symbol: "%",
+          subunit_to_unit: 100
+        )
+        new_currency = Currency.find("XXX")
+        expect(new_currency).not_to be_nil
+        expect(new_currency.name).to eq "Golden Doubloon"
+        expect(new_currency.symbol).to eq "%"
+      end
 
-    specify ":iso_code must be present" do
-      expect {
-        Money::Currency.register(name: "New Currency")
-      }.to raise_error(KeyError)
+      specify ":iso_code must be present" do
+        expect {
+          Currency.register(name: "New Currency")
+        }.to raise_error(KeyError)
+      end
     end
-  end
 
 
-  describe ".unregister" do
-    it "unregisters a currency" do
-      Money::Currency.register(iso_code: "XXX")
-      expect(Money::Currency.find("XXX")).not_to be_nil # Sanity check
-      Money::Currency.unregister(iso_code: "XXX")
-      expect(Money::Currency.find("XXX")).to be_nil
-    end
+    describe ".unregister" do
+      it "unregisters a currency" do
+        Currency.register(iso_code: "XXX")
+        expect(Currency.find("XXX")).not_to be_nil # Sanity check
+        Currency.unregister(iso_code: "XXX")
+        expect(Currency.find("XXX")).to be_nil
+      end
 
-    it "returns true iff the currency existed" do
-      Money::Currency.register(iso_code: "XXX")
-      expect(Money::Currency.unregister(iso_code: "XXX")).to be_truthy
-      expect(Money::Currency.unregister(iso_code: "XXX")).to be_falsey
-    end
+      it "returns true iff the currency existed" do
+        Currency.register(iso_code: "XXX")
+        expect(Currency.unregister(iso_code: "XXX")).to be_truthy
+        expect(Currency.unregister(iso_code: "XXX")).to be_falsey
+      end
 
-    it "can be passed an ISO code" do
-      Money::Currency.register(iso_code: "XXX")
-      Money::Currency.register(iso_code: "YYZ")
-      # Test with string:
-      Money::Currency.unregister("XXX")
-      expect(Money::Currency.find("XXX")).to be_nil
-      # Test with symbol:
-      Money::Currency.unregister(:yyz)
-      expect(Money::Currency.find(:yyz)).to be_nil
+      it "can be passed an ISO code" do
+        Currency.register(iso_code: "XXX")
+        Currency.register(iso_code: "YYZ")
+        # Test with string:
+        Currency.unregister("XXX")
+        expect(Currency.find("XXX")).to be_nil
+        # Test with symbol:
+        Currency.unregister(:yyz)
+        expect(Currency.find(:yyz)).to be_nil
+      end
     end
-  end
 
 
-  describe ".each" do
-    it "yields each currency to the block" do
-      expect(Money::Currency).to respond_to(:each)
-      currencies = []
-      Money::Currency.each do |currency|
-        currencies.push(currency)
+    describe ".each" do
+      it "yields each currency to the block" do
+        expect(Currency).to respond_to(:each)
+        currencies = []
+        Currency.each do |currency|
+          currencies.push(currency)
+        end
+
+        # Don't bother testing every single currency
+        expect(currencies[0]).to eq Currency.all[0]
+        expect(currencies[1]).to eq Currency.all[1]
+        expect(currencies[-1]).to eq Currency.all[-1]
       end
+    end
+
 
-      # Don't bother testing every single currency
-      expect(currencies[0]).to eq Money::Currency.all[0]
-      expect(currencies[1]).to eq Money::Currency.all[1]
-      expect(currencies[-1]).to eq Money::Currency.all[-1]
+    it "implements Enumerable" do
+      expect(Currency).to respond_to(:all?)
+      expect(Currency).to respond_to(:each_with_index)
+      expect(Currency).to respond_to(:map)
+      expect(Currency).to respond_to(:select)
+      expect(Currency).to respond_to(:reject)
     end
-  end
 
 
-  it "implements Enumerable" do
-    expect(Money::Currency).to respond_to(:all?)
-    expect(Money::Currency).to respond_to(:each_with_index)
-    expect(Money::Currency).to respond_to(:map)
-    expect(Money::Currency).to respond_to(:select)
-    expect(Money::Currency).to respond_to(:reject)
-  end
+    describe "#initialize" do
+      before { Currency.instances.clear }
+      it "lookups data from loaded config" do
+        currency = Currency.new("USD")
+        expect(currency.id).to                    eq :usd
+        expect(currency.priority).to              eq 1
+        expect(currency.iso_code).to              eq "USD"
+        expect(currency.iso_numeric).to           eq "840"
+        expect(currency.name).to                  eq "United States Dollar"
+        expect(currency.decimal_mark).to          eq "."
+        expect(currency.separator).to             eq "."
+        expect(currency.thousands_separator).to   eq ","
+        expect(currency.delimiter).to             eq ","
+        expect(currency.smallest_denomination).to eq 1
+      end
 
+      it "raises UnknownCurrency with unknown currency" do
+        expect { Currency.new("xxx") }.to raise_error(Currency::UnknownCurrency, /xxx/)
+      end
 
-  describe "#initialize" do
-    it "lookups data from loaded config" do
-      currency = Money::Currency.new("USD")
-      expect(currency.id).to                    eq :usd
-      expect(currency.priority).to              eq 1
-      expect(currency.iso_code).to              eq "USD"
-      expect(currency.iso_numeric).to           eq "840"
-      expect(currency.name).to                  eq "United States Dollar"
-      expect(currency.decimal_mark).to          eq "."
-      expect(currency.separator).to             eq "."
-      expect(currency.thousands_separator).to   eq ","
-      expect(currency.delimiter).to             eq ","
-      expect(currency.smallest_denomination).to eq 1
-    end
+      it 'returns old object for the same :key' do
+        expect(Currency.new("USD")).to be(Currency.new("USD"))
+        expect(Currency.new("USD")).to be(Currency.new(:usd))
+        expect(Currency.new("USD")).to be(Currency.new(:USD))
+        expect(Currency.new("USD")).to be(Currency.new('usd'))
+        expect(Currency.new("USD")).to be(Currency.new('Usd'))
+      end
 
-    it "raises UnknownMoney::Currency with unknown currency" do
-      expect { Money::Currency.new("xxx") }.to raise_error(Money::Currency::UnknownCurrency, /xxx/)
-    end
-  end
+      it 'returns new object for the different :key' do
+        expect(Currency.new("USD")).to_not be(Currency.new("EUR"))
+      end
 
-  describe "#<=>" do
-    it "compares objects by priority" do
-      expect(Money::Currency.new(:cad)).to be > Money::Currency.new(:usd)
-      expect(Money::Currency.new(:usd)).to be < Money::Currency.new(:eur)
+      it 'is thread safe' do
+        ids = []
+        2.times.map{ Thread.new{ ids << Currency.new("USD").object_id }}.each(&:join)
+        expect(ids.uniq.length).to eq(1)
+      end
     end
 
-    it "compares by id when priority is the same" do
-      Money::Currency.register(iso_code: "ABD", priority: 15)
-      Money::Currency.register(iso_code: "ABC", priority: 15)
-      Money::Currency.register(iso_code: "ABE", priority: 15)
-      abd = Money::Currency.find("ABD")
-      abc = Money::Currency.find("ABC")
-      abe = Money::Currency.find("ABE")
-      expect(abd).to be > abc
-      expect(abe).to be > abd
-      Money::Currency.unregister("ABD")
-      Money::Currency.unregister("ABC")
-      Money::Currency.unregister("ABE")
-    end
+    describe "#<=>" do
+      it "compares objects by priority" do
+        expect(Currency.new(:cad)).to be > Currency.new(:usd)
+        expect(Currency.new(:usd)).to be < Currency.new(:eur)
+      end
 
-    context "when one of the currencies has no 'priority' set" do
-      it "compares by id" do
-        Money::Currency.register(iso_code: "ABD") # No priority
-        abd = Money::Currency.find(:abd)
-        usd = Money::Currency.find(:usd)
-        expect(abd).to be < usd
-        Money::Currency.unregister(iso_code: "ABD")
+      it "compares by id when priority is the same" do
+        Currency.register(iso_code: "ABD", priority: 15)
+        Currency.register(iso_code: "ABC", priority: 15)
+        Currency.register(iso_code: "ABE", priority: 15)
+        abd = Currency.find("ABD")
+        abc = Currency.find("ABC")
+        abe = Currency.find("ABE")
+        expect(abd).to be > abc
+        expect(abe).to be > abd
+        Currency.unregister("ABD")
+        Currency.unregister("ABC")
+        Currency.unregister("ABE")
       end
-    end
-  end
 
-  describe "#==" do
-    it "returns true if self === other" do
-      currency = Money::Currency.new(:eur)
-      expect(currency).to eq currency
+      context "when one of the currencies has no 'priority' set" do
+        it "compares by id" do
+          Currency.register(iso_code: "ABD") # No priority
+          abd = Currency.find(:abd)
+          usd = Currency.find(:usd)
+          expect(abd).to be < usd
+          Currency.unregister(iso_code: "ABD")
+        end
+      end
     end
 
-    it "returns true if the id is equal ignorning case" do
-      expect(Money::Currency.new(:eur)).to     eq Money::Currency.new(:eur)
-      expect(Money::Currency.new(:eur)).to     eq Money::Currency.new(:EUR)
-      expect(Money::Currency.new(:eur)).not_to eq Money::Currency.new(:usd)
-    end
+    describe "#==" do
+      it "returns true if self === other" do
+        currency = Currency.new(:eur)
+        expect(currency).to eq currency
+      end
 
-    it "allows direct comparison of currencies and symbols/strings" do
-      expect(Money::Currency.new(:eur)).to     eq 'eur'
-      expect(Money::Currency.new(:eur)).to     eq 'EUR'
-      expect(Money::Currency.new(:eur)).to     eq :eur
-      expect(Money::Currency.new(:eur)).to     eq :EUR
-      expect(Money::Currency.new(:eur)).not_to eq 'usd'
-    end
+      it "returns true if the id is equal ignorning case" do
+        expect(Currency.new(:eur)).to     eq Currency.new(:eur)
+        expect(Currency.new(:eur)).to     eq Currency.new(:EUR)
+        expect(Currency.new(:eur)).not_to eq Currency.new(:usd)
+      end
 
-    it "allows comparison with nil and returns false" do
-      expect(Money::Currency.new(:eur)).not_to be_nil
-    end
-  end
+      it "allows direct comparison of currencies and symbols/strings" do
+        expect(Currency.new(:eur)).to     eq 'eur'
+        expect(Currency.new(:eur)).to     eq 'EUR'
+        expect(Currency.new(:eur)).to     eq :eur
+        expect(Currency.new(:eur)).to     eq :EUR
+        expect(Currency.new(:eur)).not_to eq 'usd'
+      end
 
-  describe "#eql?" do
-    it "returns true if #== returns true" do
-      expect(Money::Currency.new(:eur).eql?(Money::Currency.new(:eur))).to be true
-      expect(Money::Currency.new(:eur).eql?(Money::Currency.new(:usd))).to be false
+      it "allows comparison with nil and returns false" do
+        expect(Currency.new(:eur)).not_to be_nil
+      end
     end
-  end
 
-  describe "#hash" do
-    it "returns the same value for equal objects" do
-      expect(Money::Currency.new(:eur).hash).to eq Money::Currency.new(:eur).hash
-      expect(Money::Currency.new(:eur).hash).not_to eq Money::Currency.new(:usd).hash
+    describe "#eql?" do
+      it "returns true if #== returns true" do
+        expect(Currency.new(:eur).eql?(Currency.new(:eur))).to be true
+        expect(Currency.new(:eur).eql?(Currency.new(:usd))).to be false
+      end
     end
 
-    it "can be used to return the intersection of Currency object arrays" do
-      intersection = [Money::Currency.new(:eur), Money::Currency.new(:usd)] & [Money::Currency.new(:eur)]
-      expect(intersection).to eq [Money::Currency.new(:eur)]
-    end
-  end
+    describe "#hash" do
+      it "returns the same value for equal objects" do
+        expect(Currency.new(:eur).hash).to eq Currency.new(:eur).hash
+        expect(Currency.new(:eur).hash).not_to eq Currency.new(:usd).hash
+      end
 
-  describe "#inspect" do
-    it "works as documented" do
-      expect(Money::Currency.new(:usd).inspect).to eq %Q{#<Money::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, exponent: 2.0, iso_code: USD, iso_numeric: 840, subunit: Cent, smallest_denomination: 1>}
+      it "can be used to return the intersection of Currency object arrays" do
+        intersection = [Currency.new(:eur), Currency.new(:usd)] & [Currency.new(:eur)]
+        expect(intersection).to eq [Currency.new(:eur)]
+      end
     end
-  end
 
-  describe "#to_s" do
-    it "works as documented" do
-      expect(Money::Currency.new(:usd).to_s).to eq("USD")
-      expect(Money::Currency.new(:eur).to_s).to eq("EUR")
+    describe "#inspect" do
+      it "works as documented" do
+        expect(Currency.new(:usd).inspect).to eq %Q{#<Money::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, exponent: 2.0, iso_code: USD, iso_numeric: 840, subunit: Cent, smallest_denomination: 1>}
+      end
     end
-  end
 
-  describe "#to_str" do
-    it "works as documented" do
-      expect(Money::Currency.new(:usd).to_str).to eq("USD")
-      expect(Money::Currency.new(:eur).to_str).to eq("EUR")
+    describe "#to_s" do
+      it "works as documented" do
+        expect(Currency.new(:usd).to_s).to eq("USD")
+        expect(Currency.new(:eur).to_s).to eq("EUR")
+      end
     end
-  end
 
-  describe "#to_sym" do
-    it "works as documented" do
-      expect(Money::Currency.new(:usd).to_sym).to eq(:USD)
-      expect(Money::Currency.new(:eur).to_sym).to eq(:EUR)
+    describe "#to_str" do
+      it "works as documented" do
+        expect(Currency.new(:usd).to_str).to eq("USD")
+        expect(Currency.new(:eur).to_str).to eq("EUR")
+      end
     end
-  end
 
-  describe "#to_currency" do
-    it "works as documented" do
-      usd = Money::Currency.new(:usd)
-      expect(usd.to_currency).to eq usd
+    describe "#to_sym" do
+      it "works as documented" do
+        expect(Currency.new(:usd).to_sym).to eq(:USD)
+        expect(Currency.new(:eur).to_sym).to eq(:EUR)
+      end
     end
 
-    it "doesn't create new symbols indefinitely" do
-      expect { Money::Currency.new("bogus") }.to raise_exception(Money::Currency::UnknownCurrency)
-      expect(Symbol.all_symbols.map{|s| s.to_s}).not_to include("bogus")
-    end
-  end
+    describe "#to_currency" do
+      it "works as documented" do
+        usd = Currency.new(:usd)
+        expect(usd.to_currency).to eq usd
+      end
 
-  describe "#code" do
-    it "works as documented" do
-      expect(Money::Currency.new(:usd).code).to eq "$"
-      expect(Money::Currency.new(:azn).code).to eq "\u20BC"
+      it "doesn't create new symbols indefinitely" do
+        expect { Currency.new("bogus") }.to raise_exception(Currency::UnknownCurrency)
+        expect(Symbol.all_symbols.map{|s| s.to_s}).not_to include("bogus")
+      end
     end
-  end
 
-  describe "#exponent" do
-    it "conforms to iso 4217" do
-      Money::Currency.new(:jpy).exponent == 0
-      Money::Currency.new(:usd).exponent == 2
-      Money::Currency.new(:iqd).exponent == 3
+    describe "#code" do
+      it "works as documented" do
+        expect(Currency.new(:usd).code).to eq "$"
+        expect(Currency.new(:azn).code).to eq "\u20BC"
+      end
     end
-  end
 
-  describe "#decimal_places" do
-    it "proper places for known currency" do
-      Money::Currency.new(:mro).decimal_places == 1
-      Money::Currency.new(:usd).decimal_places == 2
+    describe "#exponent" do
+      it "conforms to iso 4217" do
+        Currency.new(:jpy).exponent == 0
+        Currency.new(:usd).exponent == 2
+        Currency.new(:iqd).exponent == 3
+      end
     end
 
-    it "proper places for custom currency" do
-      register_foo
-      Money::Currency.new(:foo).decimal_places == 3
-      unregister_foo
+    describe "#decimal_places" do
+      it "proper places for known currency" do
+        Currency.new(:mro).decimal_places == 1
+        Currency.new(:usd).decimal_places == 2
+      end
+
+      it "proper places for custom currency" do
+        register_foo
+        Currency.new(:foo).decimal_places == 3
+        unregister_foo
+      end
     end
   end
 end