valvat 0.6.4 → 0.6.5

data/spec/valvat/utils_spec.rb

@@ -3,75 +3,75 @@ require 'spec_helper'
 describe Valvat::Utils do
   describe "#split" do
     it "returns country and rest on vat number as array" do
-      Valvat::Utils.split("DE345889003").should eql(["DE", "345889003"])
-      Valvat::Utils.split("ESX4588900X").should eql(["ES", "X4588900X"])
+      expect(Valvat::Utils.split("DE345889003")).to eql(["DE", "345889003"])
+      expect(Valvat::Utils.split("ESX4588900X")).to eql(["ES", "X4588900X"])
     end
 
     it "returns two nils on non-european iso codes as array" do
-      Valvat::Utils.split("US345889003").should eql([nil, nil])
-      Valvat::Utils.split("RUX4588900X").should eql([nil, nil])
+      expect(Valvat::Utils.split("US345889003")).to eql([nil, nil])
+      expect(Valvat::Utils.split("RUX4588900X")).to eql([nil, nil])
     end
 
     it "returns two nils on non-sense input as array" do
-      Valvat::Utils.split("DE").should eql([nil, nil])
-      Valvat::Utils.split("X345889003").should eql([nil, nil])
-      Valvat::Utils.split("").should eql([nil, nil])
-      Valvat::Utils.split("1234").should eql([nil, nil])
-      Valvat::Utils.split(" ").should eql([nil, nil])
+      expect(Valvat::Utils.split("DE")).to eql([nil, nil])
+      expect(Valvat::Utils.split("X345889003")).to eql([nil, nil])
+      expect(Valvat::Utils.split("")).to eql([nil, nil])
+      expect(Valvat::Utils.split("1234")).to eql([nil, nil])
+      expect(Valvat::Utils.split(" ")).to eql([nil, nil])
     end
 
     it "returns EL (language iso code) on greek vat" do
-      Valvat::Utils.split("EL999999999").should eql(["EL", "999999999"])
+      expect(Valvat::Utils.split("EL999999999")).to eql(["EL", "999999999"])
     end
   end
 
   describe "#normalize" do
     it "returns vat number with upcase chars" do
-      Valvat::Utils.normalize("de345889003").should eql("DE345889003")
-      Valvat::Utils.normalize("EsX4588900y").should eql("ESX4588900Y")
+      expect(Valvat::Utils.normalize("de345889003")).to eql("DE345889003")
+      expect(Valvat::Utils.normalize("EsX4588900y")).to eql("ESX4588900Y")
     end
 
     it "returns trimmed vat number" do
-      Valvat::Utils.normalize(" DE345889003").should eql("DE345889003")
-      Valvat::Utils.normalize("  DE345889003  ").should eql("DE345889003")
-      Valvat::Utils.normalize("DE345889003 ").should eql("DE345889003")
+      expect(Valvat::Utils.normalize(" DE345889003")).to eql("DE345889003")
+      expect(Valvat::Utils.normalize("  DE345889003  ")).to eql("DE345889003")
+      expect(Valvat::Utils.normalize("DE345889003 ")).to eql("DE345889003")
     end
 
     it "does not change already normalized vat numbers" do
-      Valvat::Utils.normalize("DE345889003").should eql("DE345889003")
-      Valvat::Utils.normalize("ESX4588900X").should eql("ESX4588900X")
+      expect(Valvat::Utils.normalize("DE345889003")).to eql("DE345889003")
+      expect(Valvat::Utils.normalize("ESX4588900X")).to eql("ESX4588900X")
     end
 
     it "removes spaces" do
-      Valvat::Utils.normalize("DE 345889003").should eql("DE345889003")
-      Valvat::Utils.normalize("ESX  458 8900 X").should eql("ESX4588900X")
+      expect(Valvat::Utils.normalize("DE 345889003")).to eql("DE345889003")
+      expect(Valvat::Utils.normalize("ESX  458 8900 X")).to eql("ESX4588900X")
     end
 
     it "removes special chars" do
-      Valvat::Utils.normalize("DE.345-889_00:3,;").should eql("DE345889003")
+      expect(Valvat::Utils.normalize("DE.345-889_00:3,;")).to eql("DE345889003")
     end
   end
 
   describe "#vat_country_to_iso_country" do
     it "returns iso country code on greek iso language 'EL'" do
-      Valvat::Utils.vat_country_to_iso_country("EL").should eql("GR")
+      expect(Valvat::Utils.vat_country_to_iso_country("EL")).to eql("GR")
     end
 
     Valvat::Utils::EU_COUNTRIES.each do |iso|
       it "returns unchanged iso country code '#{iso}'" do
-        Valvat::Utils.vat_country_to_iso_country(iso).should eql(iso)
+        expect(Valvat::Utils.vat_country_to_iso_country(iso)).to eql(iso)
       end
     end
   end
 
   describe "#iso_country_to_vat_country" do
     it "returns vat country on greek iso country code 'GR'" do
-      Valvat::Utils.iso_country_to_vat_country("GR").should eql("EL")
+      expect(Valvat::Utils.iso_country_to_vat_country("GR")).to eql("EL")
     end
 
     Valvat::Utils::EU_COUNTRIES.reject{|c| c == "GR"}.each do |c|
       it "returns unchanged vat country code '#{c}'" do
-        Valvat::Utils.iso_country_to_vat_country(c).should eql(c)
+        expect(Valvat::Utils.iso_country_to_vat_country(c)).to eql(c)
       end
     end
   end

data/spec/valvat_spec.rb

@@ -5,26 +5,26 @@ require 'spec_helper'
 describe Valvat do
   describe "#new" do
     it "demands one and only one argument" do
-      lambda{ Valvat.new }.should raise_error(ArgumentError)
-      lambda{ Valvat.new("a", "b") }.should raise_error(ArgumentError)
-      lambda{ Valvat.new("a") }.should_not raise_error
+      expect{ Valvat.new }.to raise_error(ArgumentError)
+      expect{ Valvat.new("a", "b") }.to raise_error(ArgumentError)
+      expect{ Valvat.new("a") }.not_to raise_error
     end
 
     it "normalizes input string" do
-      Valvat.new("de25.9597,69 7").to_s.should eql("DE259597697")
-      Valvat.new("de25.9597,69 7").iso_country_code.should eql("DE")
+      expect(Valvat.new("de25.9597,69 7").to_s).to eql("DE259597697")
+      expect(Valvat.new("de25.9597,69 7").iso_country_code).to eql("DE")
     end
   end
 
   context "Valvat()" do
     it "initializes new Valvat instance on string" do
-      Valvat("abc").should be_kind_of(Valvat)
+      expect(Valvat("abc")).to be_kind_of(Valvat)
     end
 
     it "returns same Valvat instance on Valvat instance" do
       vat = Valvat.new("abc")
-      Valvat(vat).should be_kind_of(Valvat)
-      Valvat(vat).object_id.should eql(vat.object_id)
+      expect(Valvat(vat)).to be_kind_of(Valvat)
+      expect(Valvat(vat).object_id).to eql(vat.object_id)
     end
   end
 
@@ -32,15 +32,15 @@ describe Valvat do
   describe "#blank?" do
     
     it "returns true when when initialized with nil" do
-      Valvat.new(nil).should be_blank
+      expect(Valvat.new(nil)).to be_blank
     end
 
     it "returns true when when initialized with an empty string" do
-      Valvat.new(" ").should be_blank
+      expect(Valvat.new(" ")).to be_blank
     end
 
     it "returns false when initialized with a value" do
-      Valvat.new("DE259597697").should_not be_blank
+      expect(Valvat.new("DE259597697")).not_to be_blank
     end
   end
 
@@ -52,111 +52,111 @@ describe Valvat do
 
     describe "#valid?" do
       it "returns true on valid numbers" do
-        de_vat.should be_valid
-        gr_vat.should be_valid
+        expect(de_vat).to be_valid
+        expect(gr_vat).to be_valid
       end
 
       it "returns false on invalid numbers" do
-        at_vat.should_not be_valid
+        expect(at_vat).not_to be_valid
       end
     end
 
     describe "#valid_checksum?" do
       it "returns true on valid numbers" do
-        de_vat.should be_valid_checksum
-        gr_vat.should be_valid_checksum
+        expect(de_vat).to be_valid_checksum
+        expect(gr_vat).to be_valid_checksum
       end
 
       it "returns false on invalid numbers" do
-        at_vat.should_not be_valid_checksum
-        invalid_checksum.should_not be_valid_checksum
+        expect(at_vat).not_to be_valid_checksum
+        expect(invalid_checksum).not_to be_valid_checksum
       end
     end
 
     describe "#exist(s)?" do
       context "on existing vat numbers" do
         before do
-          Valvat::Lookup.stub(:validate => true)
+          allow(Valvat::Lookup).to receive_messages(:validate => true)
         end
 
         it "returns true" do
-          de_vat.exists?.should eql(true)
-          gr_vat.exists?.should eql(true)
-          de_vat.exist?.should eql(true)
-          gr_vat.exist?.should eql(true)
+          expect(de_vat.exists?).to eql(true)
+          expect(gr_vat.exists?).to eql(true)
+          expect(de_vat.exist?).to eql(true)
+          expect(gr_vat.exist?).to eql(true)
         end
       end
 
       context "on not existing vat numbers" do
         before do
-          Valvat::Lookup.stub(:validate => false)
+          allow(Valvat::Lookup).to receive_messages(:validate => false)
         end
 
         it "returns false" do
-          at_vat.exists?.should eql(false)
-          at_vat.exist?.should eql(false)
+          expect(at_vat.exists?).to eql(false)
+          expect(at_vat.exist?).to eql(false)
         end
       end
 
       context "with options" do
         it "calls Valvat::Lookup.validate with options" do
-          Valvat::Lookup.should_receive(:validate).once.with(de_vat, :detail => true, :bla => 'blupp').and_return(true)
-          de_vat.exists?(:detail => true, :bla => 'blupp').should eql(true)
+          expect(Valvat::Lookup).to receive(:validate).once.with(de_vat, :detail => true, :bla => 'blupp').and_return(true)
+          expect(de_vat.exists?(:detail => true, :bla => 'blupp')).to eql(true)
         end
       end
     end
 
     describe "#iso_country_code" do
       it "returns iso country code on iso_country_code" do
-        de_vat.iso_country_code.should eql("DE")
-        at_vat.iso_country_code.should eql("AT")
+        expect(de_vat.iso_country_code).to eql("DE")
+        expect(at_vat.iso_country_code).to eql("AT")
       end
 
       it "returns GR iso country code on greek vat number" do
-        gr_vat.iso_country_code.should eql("GR")
+        expect(gr_vat.iso_country_code).to eql("GR")
       end
     end
 
     describe "#vat_country_code" do
       it "returns iso country code on iso_country_code" do
-        de_vat.vat_country_code.should eql("DE")
-        at_vat.vat_country_code.should eql("AT")
+        expect(de_vat.vat_country_code).to eql("DE")
+        expect(at_vat.vat_country_code).to eql("AT")
       end
 
       it "returns EL iso language code on greek vat number" do
-        gr_vat.vat_country_code.should eql("EL")
+        expect(gr_vat.vat_country_code).to eql("EL")
       end
     end
 
     describe "#european?" do
       it "returns true" do
-        de_vat.should be_european
-        at_vat.should be_european
-        gr_vat.should be_european
+        expect(de_vat).to be_european
+        expect(at_vat).to be_european
+        expect(gr_vat).to be_european
       end
     end
 
     describe "#to_s" do
       it "returns full vat number" do
-        de_vat.to_s.should eql("DE259597697")
-        at_vat.to_s.should eql("ATU458890031")
-        gr_vat.to_s.should eql("EL999943280")
+        expect(de_vat.to_s).to eql("DE259597697")
+        expect(at_vat.to_s).to eql("ATU458890031")
+        expect(gr_vat.to_s).to eql("EL999943280")
       end
     end
 
     describe "#inspect" do
       it "returns vat number with iso country code" do
-        de_vat.inspect.should eql("#<Valvat DE259597697 DE>")
-        at_vat.inspect.should eql("#<Valvat ATU458890031 AT>")
-        gr_vat.inspect.should eql("#<Valvat EL999943280 GR>")
+        expect(de_vat.inspect).to eql("#<Valvat DE259597697 DE>")
+        expect(at_vat.inspect).to eql("#<Valvat ATU458890031 AT>")
+        expect(gr_vat.inspect).to eql("#<Valvat EL999943280 GR>")
       end
     end
 
     describe "#to_a" do
       it "calls Valvat::Utils.split with raw vat number and returns result" do
         de_vat # initialize
-        Valvat::Utils.should_receive(:split).once.with("DE259597697").and_return(["a", "b"])
-        de_vat.to_a.should eql(["a", "b"])
+        expect(Valvat::Utils).to receive(:split).once.with("DE259597697").and_return(["a", "b"])
+        expect(de_vat.to_a).to eql(["a", "b"])
       end
     end
   end
@@ -167,8 +167,8 @@ describe Valvat do
 
     describe "#valid?" do
       it "returns false" do
-        us_vat.should_not be_valid
-        ch_vat.should_not be_valid
+        expect(us_vat).not_to be_valid
+        expect(ch_vat).not_to be_valid
       end
     end
 
@@ -176,43 +176,43 @@ describe Valvat do
       without_any_web_requests!
 
       it "returns false" do
-        us_vat.should_not be_exist
-        ch_vat.should_not be_exist
+        expect(us_vat).not_to be_exist
+        expect(ch_vat).not_to be_exist
       end
     end
 
     describe "#iso_country_code" do
       it "returns nil" do
-        us_vat.iso_country_code.should eql(nil)
-        ch_vat.iso_country_code.should eql(nil)
+        expect(us_vat.iso_country_code).to eql(nil)
+        expect(ch_vat.iso_country_code).to eql(nil)
       end
     end
 
     describe "#vat_country_code" do
       it "returns nil" do
-        us_vat.vat_country_code.should eql(nil)
-        ch_vat.vat_country_code.should eql(nil)
+        expect(us_vat.vat_country_code).to eql(nil)
+        expect(ch_vat.vat_country_code).to eql(nil)
       end
     end
 
     describe "#european?" do
       it "returns false" do
-        us_vat.should_not be_european
-        ch_vat.should_not be_european
+        expect(us_vat).not_to be_european
+        expect(ch_vat).not_to be_european
       end
     end
 
     describe "#to_s" do
       it "returns full given vat number" do
-        us_vat.to_s.should eql("US345889003")
-        ch_vat.to_s.should eql("CH445889003")
+        expect(us_vat.to_s).to eql("US345889003")
+        expect(ch_vat.to_s).to eql("CH445889003")
       end
     end
 
     describe "#inspect" do
       it "returns vat number without iso country code" do
-        us_vat.inspect.should eql("#<Valvat US345889003>")
-        ch_vat.inspect.should eql("#<Valvat CH445889003>")
+        expect(us_vat.inspect).to eql("#<Valvat US345889003>")
+        expect(ch_vat.inspect).to eql("#<Valvat CH445889003>")
       end
     end
 
@@ -226,10 +226,10 @@ describe Valvat do
 
     describe "#valid?" do
       it "returns false" do
-        only_iso_vat.should_not be_valid
-        num_vat.should_not be_valid
-        empty_vat.should_not be_valid
-        nil_vat.should_not be_valid
+        expect(only_iso_vat).not_to be_valid
+        expect(num_vat).not_to be_valid
+        expect(empty_vat).not_to be_valid
+        expect(nil_vat).not_to be_valid
       end
     end
 
@@ -237,55 +237,55 @@ describe Valvat do
       without_any_web_requests!
 
       it "returns false" do
-        only_iso_vat.should_not be_exist
-        num_vat.should_not be_exist
-        empty_vat.should_not be_exist
-        nil_vat.should_not be_exist
+        expect(only_iso_vat).not_to be_exist
+        expect(num_vat).not_to be_exist
+        expect(empty_vat).not_to be_exist
+        expect(nil_vat).not_to be_exist
       end
     end
 
     describe "#iso_country_code" do
       it "returns nil" do
-        only_iso_vat.iso_country_code.should eql(nil)
-        num_vat.iso_country_code.should eql(nil)
-        empty_vat.iso_country_code.should eql(nil)
-        nil_vat.iso_country_code.should eql(nil)
+        expect(only_iso_vat.iso_country_code).to eql(nil)
+        expect(num_vat.iso_country_code).to eql(nil)
+        expect(empty_vat.iso_country_code).to eql(nil)
+        expect(nil_vat.iso_country_code).to eql(nil)
       end
     end
 
     describe "#vat_country_code" do
       it "returns nil" do
-        only_iso_vat.vat_country_code.should eql(nil)
-        num_vat.vat_country_code.should eql(nil)
-        empty_vat.vat_country_code.should eql(nil)
-        nil_vat.vat_country_code.should eql(nil)
+        expect(only_iso_vat.vat_country_code).to eql(nil)
+        expect(num_vat.vat_country_code).to eql(nil)
+        expect(empty_vat.vat_country_code).to eql(nil)
+        expect(nil_vat.vat_country_code).to eql(nil)
       end
     end
 
     describe "#european?" do
       it "returns false" do
-        only_iso_vat.should_not be_european
-        num_vat.should_not be_european
-        empty_vat.should_not be_european
-        nil_vat.should_not be_european
+        expect(only_iso_vat).not_to be_european
+        expect(num_vat).not_to be_european
+        expect(empty_vat).not_to be_european
+        expect(nil_vat).not_to be_european
       end
     end
 
     describe "#to_s" do
       it "returns full given vat number" do
-        only_iso_vat.to_s.should eql("DE")
-        num_vat.to_s.should eql("12445889003")
-        empty_vat.to_s.should eql("")
-        nil_vat.to_s.should eql("")
+        expect(only_iso_vat.to_s).to eql("DE")
+        expect(num_vat.to_s).to eql("12445889003")
+        expect(empty_vat.to_s).to eql("")
+        expect(nil_vat.to_s).to eql("")
       end
     end
 
     describe "#inspect" do
       it "returns vat number without iso country code" do
-        only_iso_vat.inspect.should eql("#<Valvat DE>")
-        num_vat.inspect.should eql("#<Valvat 12445889003>")
-        empty_vat.inspect.should eql("#<Valvat >")
-        nil_vat.inspect.should eql("#<Valvat >")
+        expect(only_iso_vat.inspect).to eql("#<Valvat DE>")
+        expect(num_vat.inspect).to eql("#<Valvat 12445889003>")
+        expect(empty_vat.inspect).to eql("#<Valvat >")
+        expect(nil_vat.inspect).to eql("#<Valvat >")
       end
     end