valvat 0.6.4 → 0.6.5

data/spec/valvat/checksum/be_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::BE do
   %w(BE0123456749 BE0136695962 BE0817331995).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/bg_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::BG do
   %w(BG123456786 BG926067143 BG926067770 BG0101011739 BG0121013021 BG5041019992 BG1521687837 BG1431889037).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-1]}#{valid_vat[-2]}#{valid_vat[-4]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/de_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::DE do
   %w(DE280857971 DE281381706 DE283108332 DE813622378 DE813628528 DE814178359 DE811907980).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/dk_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::DK do
   %w(DK13585628 DK61126228).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/es_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::ES do
   %w(ESA13585625 ESB83871236 ESE54507058 ES25139013J ESQ1518001A ESQ5018001G ESX4942978W ESX7676464F ESB10317980).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-6]}#{valid_vat[-2]}#{valid_vat[-5]}#{valid_vat[-4]}#{valid_vat[-3]}#{valid_vat[-1]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/fi_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::FI do
   %w(FI13669598 FI20584306 FI01080233).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-1]}#{valid_vat[-2]}#{valid_vat[-3]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/gr_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::GR do
   %w(EL123456783 EL094543092 EL998219694).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/ie_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::IE do
   %w(IE8473625E IE0123459N IE9B12345N).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-2]}#{valid_vat[-3]}#{valid_vat[-1]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/it_spec.rb

@@ -3,21 +3,21 @@ require 'spec_helper'
 describe Valvat::Checksum::IT do
   %w(IT12345670785 IT01897810162 IT00197200132 IT02762750210).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 
   it "returns false on invalid special case vat IT12345671783" do
-    Valvat::Checksum.validate("IT12345671783").should eql(false)
+    expect(Valvat::Checksum.validate("IT12345671783")).to eql(false)
   end
 
   it "returns false on invalid special case vat IT00000000133" do
-    Valvat::Checksum.validate("IT00000000133").should eql(false)
+    expect(Valvat::Checksum.validate("IT00000000133")).to eql(false)
   end
 end

data/spec/valvat/checksum/lu_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::LU do
   %w(LU13669580 LU25361352 LU23124018 LU17560609).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-2]}#{valid_vat[-3]}#{valid_vat[-1]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/nl_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Valvat::Checksum::NL do
   %w(NL123456782B12 NL802549391B01 NL808661863B01 NL820893559B01).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-5]}#{valid_vat[-2]}#{valid_vat[-3]}#{valid_vat[-4]}#{valid_vat[-1]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 end

data/spec/valvat/checksum/pl_spec.rb

@@ -3,17 +3,17 @@ require 'spec_helper'
 describe Valvat::Checksum::PL do
   %w(PL8567346215 PL5260211587 PL9720575348 PL5272650022).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-1]}#{valid_vat[-2]}#{valid_vat[-3]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 
   it "returns false on special case invalid vat PL8566445330" do
-    Valvat::Checksum.validate("PL8566445330").should eql(false)
+    expect(Valvat::Checksum.validate("PL8566445330")).to eql(false)
   end
 end

data/spec/valvat/checksum/pt_spec.rb

@@ -6,13 +6,13 @@ describe Valvat::Checksum::PT do
 
   %w(PT136695973 PT501413197 PT503037753 PT500243590 PT500100144 PT502921838).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      subject.validate(valid_vat).should be_true
+      expect(subject.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-5]}#{valid_vat[-1]}#{valid_vat[-4]}#{valid_vat[-2]}#{valid_vat[-3]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      subject.validate(invalid_vat).should be_false
+      expect(subject.validate(invalid_vat)).to eql(false)
     end
   end
 
@@ -25,7 +25,7 @@ describe Valvat::Checksum::PT do
   # http://www.nif.pt/nif-das-empresas/
   %w(PT148166644 PT111623448 PT204874866 PT292261314 PT579104222 PT628910002 PT812627318 PT943935784).each do |number|
     it "returns true on a valid number - #{number}" do
-      subject.validate(number).should be_true
+      expect(subject.validate(number)).to eql(true)
     end
   end
 end

data/spec/valvat/checksum/se_spec.rb

@@ -3,17 +3,17 @@ require 'spec_helper'
 describe Valvat::Checksum::SE do
   %w(SE136695975501 SE556464687401 SE502052817901 SE556555952201 SE556084097601).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-1]}#{valid_vat[-2]}#{valid_vat[-3]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 
   it "returns false on special case invalid vat SE556464687400" do
-    Valvat::Checksum.validate("SE556464687400").should eql(false)
+    expect(Valvat::Checksum.validate("SE556464687400")).to eql(false)
   end
 end

data/spec/valvat/checksum/si_spec.rb

@@ -3,21 +3,21 @@ require 'spec_helper'
 describe Valvat::Checksum::SI do
   %w(SI59082437 SI51049406 SI86154575 SI47431857 SI22511822 SI22511880).each do |valid_vat|
     it "returns true on valid vat #{valid_vat}" do
-      Valvat::Checksum.validate(valid_vat).should eql(true)
+      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
     end
 
     invalid_vat = "#{valid_vat[0..-5]}#{valid_vat[-1]}#{valid_vat[-4]}#{valid_vat[-3]}#{valid_vat[-2]}"
 
     it "returns false on invalid vat #{invalid_vat}" do
-      Valvat::Checksum.validate(invalid_vat).should eql(false)
+      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
     end
   end
 
   it "returns false on special case invalid vat SI11111107" do
-    Valvat::Checksum.validate("SI11111107").should eql(false)
+    expect(Valvat::Checksum.validate("SI11111107")).to eql(false)
   end
 
   it "returns false on special case invalid vat SI01111108" do
-    Valvat::Checksum.validate("SI01111108").should eql(false)
+    expect(Valvat::Checksum.validate("SI01111108")).to eql(false)
   end
 end

data/spec/valvat/checksum_spec.rb

@@ -9,16 +9,16 @@ end
 describe Valvat::Checksum do
   describe "#validate" do
     it "returns true on vat number with unknown checksum algorithm" do
-      Valvat::Checksum.validate("FR99123543267").should eql(true)
+      expect(Valvat::Checksum.validate("FR99123543267")).to eql(true)
     end
 
     it "returns false on corrupt number (e.g checks syntax)" do
-      Valvat::Checksum.validate("FI1234567891").should eql(false)
+      expect(Valvat::Checksum.validate("FI1234567891")).to eql(false)
     end
 
     VALID_VAT_NUMBERS.each do |valid_vat|
       it "returns true on valid vat number #{valid_vat}" do
-        Valvat::Checksum.validate(valid_vat).should eql(true)
+        expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
       end
     end
   end

data/spec/valvat/lookup_spec.rb

@@ -8,7 +8,7 @@ describe Valvat::Lookup do
         result = Valvat::Lookup.validate("LU21416127")
 
         unless result.nil?
-          result.should eql(true)
+          expect(result).to eql(true)
         else
           puts "Skipping LU vies lookup spec"
         end
@@ -18,7 +18,7 @@ describe Valvat::Lookup do
         result = Valvat::Lookup.validate(Valvat.new("LU21416127"))
 
         unless result.nil?
-          result.should eql(true)
+          expect(result).to eql(true)
         else
           puts "Skipping LU vies lookup spec"
         end
@@ -30,7 +30,7 @@ describe Valvat::Lookup do
         result =  Valvat::Lookup.validate("LU21416128")
 
         unless result.nil?
-          result.should eql(false)
+          expect(result).to eql(false)
         else
           puts "Skipping LU vies lookup spec"
         end
@@ -41,8 +41,8 @@ describe Valvat::Lookup do
       without_any_web_requests!
 
       it "returns false" do
-        Valvat::Lookup.validate("AE259597697").should eql(false)
-        Valvat::Lookup.validate("").should eql(false)
+        expect(Valvat::Lookup.validate("AE259597697")).to eql(false)
+        expect(Valvat::Lookup.validate("")).to eql(false)
       end
     end
 
@@ -51,8 +51,8 @@ describe Valvat::Lookup do
         result = Valvat::Lookup.validate("IE6388047V", :detail => true)
 
          if result
-          result.delete(:request_date).should be_kind_of(Date)
-          result.should eql({
+          expect(result.delete(:request_date)).to be_kind_of(Date)
+          expect(result).to eql({
             :country_code=>"IE",
             :vat_number=>"6388047V",
             :name=>"GOOGLE IRELAND LIMITED",
@@ -65,8 +65,8 @@ describe Valvat::Lookup do
         result = Valvat::Lookup.validate("LU21416127", :detail => true)
 
         if result
-          result.delete(:request_date).should be_kind_of(Date)
-          result.should eql({
+          expect(result.delete(:request_date)).to be_kind_of(Date)
+          expect(result).to eql({
             :country_code=>"LU",
             :vat_number=>"21416127",
             :name=>"EBAY EUROPE S.A R.L.",
@@ -81,7 +81,7 @@ describe Valvat::Lookup do
         result =  Valvat::Lookup.validate("LU21416128", :detail => true)
 
         unless result.nil?
-          result.should eql(false)
+          expect(result).to eql(false)
         else
           puts "Skipping LU vies lookup spec"
         end
@@ -93,10 +93,10 @@ describe Valvat::Lookup do
         response = Valvat::Lookup.validate("LU21416127", :requester_vat => "IE6388047V")
 
         if response
-          response[:request_identifier].size.should eql(16)
+          expect(response[:request_identifier].size).to eql(16)
           request_identifier = response[:request_identifier]
-          response.delete(:request_date).should be_kind_of(Date)
-          response.should eql({
+          expect(response.delete(:request_date)).to be_kind_of(Date)
+          expect(response).to eql({
             :country_code=>"LU",
             :vat_number=>"21416127",
             :name => "EBAY EUROPE S.A R.L.",
@@ -113,16 +113,16 @@ describe Valvat::Lookup do
     context "error on request" do
       before do
         @request = double("request")
-        Valvat::Lookup::Request.stub(:new => @request)
-        @request.stub(:perform).and_raise(ArgumentError.new)
+        allow(Valvat::Lookup::Request).to receive_messages(:new => @request)
+        allow(@request).to receive(:perform).and_raise(ArgumentError.new)
       end
 
       it "should return nil" do
-        Valvat::Lookup.validate("LU21416127").should eql(nil)
+        expect(Valvat::Lookup.validate("LU21416127")).to eql(nil)
       end
 
       it "should raise error with raise_error option" do
-        lambda {Valvat::Lookup.validate("LU21416127", :raise_error => true)}.should raise_error(ArgumentError)
+        expect {Valvat::Lookup.validate("LU21416127", :raise_error => true)}.to raise_error(ArgumentError)
       end
     end
 

data/spec/valvat/syntax_spec.rb

@@ -3,285 +3,285 @@ require 'spec_helper'
 describe Valvat::Syntax do
   describe "#validate" do
     it "validates a DE vat number" do
-      subject.validate("DE345889003").should eql(true)
+      expect(subject.validate("DE345889003")).to eql(true)
 
-      subject.validate("DE34588900").should eql(false)
-      subject.validate("DE3458890090").should eql(false)
-      subject.validate("DE34588900C").should eql(false)
+      expect(subject.validate("DE34588900")).to eql(false)
+      expect(subject.validate("DE3458890090")).to eql(false)
+      expect(subject.validate("DE34588900C")).to eql(false)
     end
 
     it "validates a AT vat number" do
-      subject.validate("ATU03458890").should eql(true)
+      expect(subject.validate("ATU03458890")).to eql(true)
 
-      subject.validate("ATU034588908").should eql(false)
-      subject.validate("ATU0345908").should eql(false)
-      subject.validate("ATU0345889Y").should eql(false)
+      expect(subject.validate("ATU034588908")).to eql(false)
+      expect(subject.validate("ATU0345908")).to eql(false)
+      expect(subject.validate("ATU0345889Y")).to eql(false)
     end
 
     it "should validate BE vat number" do
-      subject.validate("BE0817331995").should eql(true)
+      expect(subject.validate("BE0817331995")).to eql(true)
 
-      subject.validate("BE081733199").should eql(false)
-      subject.validate("BE08173319944").should eql(false)
-      subject.validate("BE081733199H").should eql(false)
-      subject.validate("BE1817331999").should eql(false)
+      expect(subject.validate("BE081733199")).to eql(false)
+      expect(subject.validate("BE08173319944")).to eql(false)
+      expect(subject.validate("BE081733199H")).to eql(false)
+      expect(subject.validate("BE1817331999")).to eql(false)
     end
 
     it "validates a BG vat number" do
-      subject.validate("BG468134789").should eql(true)
-      subject.validate("BG4681347897").should eql(true)
+      expect(subject.validate("BG468134789")).to eql(true)
+      expect(subject.validate("BG4681347897")).to eql(true)
 
-      subject.validate("BG46813478979").should eql(false)
-      subject.validate("BG4681347897C").should eql(false)
-      subject.validate("BG46813478G").should eql(false)
-      subject.validate("BG46813478").should eql(false)
+      expect(subject.validate("BG46813478979")).to eql(false)
+      expect(subject.validate("BG4681347897C")).to eql(false)
+      expect(subject.validate("BG46813478G")).to eql(false)
+      expect(subject.validate("BG46813478")).to eql(false)
     end
 
     it "validates a CY vat number" do
-      subject.validate("CY36579347A").should eql(true)
-      subject.validate("CY36579347C").should eql(true)
+      expect(subject.validate("CY36579347A")).to eql(true)
+      expect(subject.validate("CY36579347C")).to eql(true)
 
-      subject.validate("CY36579347").should eql(false)
-      subject.validate("CY365793478").should eql(false)
-      subject.validate("CY365793478A").should eql(false)
-      subject.validate("CY365793G").should eql(false)
+      expect(subject.validate("CY36579347")).to eql(false)
+      expect(subject.validate("CY365793478")).to eql(false)
+      expect(subject.validate("CY365793478A")).to eql(false)
+      expect(subject.validate("CY365793G")).to eql(false)
     end
 
     it "validates a DK vat number" do
-      subject.validate("DK67893463").should eql(true)
+      expect(subject.validate("DK67893463")).to eql(true)
 
-      subject.validate("DK678934637").should eql(false)
-      subject.validate("DK6789346").should eql(false)
-      subject.validate("DK6789346H").should eql(false)
+      expect(subject.validate("DK678934637")).to eql(false)
+      expect(subject.validate("DK6789346")).to eql(false)
+      expect(subject.validate("DK6789346H")).to eql(false)
     end
 
     it "validates a ES vat number" do
-      subject.validate("ESX67345987").should eql(true)
-      subject.validate("ESA6734598B").should eql(true)
-      subject.validate("ES56734598C").should eql(true)
+      expect(subject.validate("ESX67345987")).to eql(true)
+      expect(subject.validate("ESA6734598B")).to eql(true)
+      expect(subject.validate("ES56734598C")).to eql(true)
 
-      subject.validate("ES167345987").should eql(false)
-      subject.validate("ESX6734598").should eql(false)
-      subject.validate("ESX673459890").should eql(false)
+      expect(subject.validate("ES167345987")).to eql(false)
+      expect(subject.validate("ESX6734598")).to eql(false)
+      expect(subject.validate("ESX673459890")).to eql(false)
     end
 
     it "validates a EE vat number" do
-      subject.validate("EE678678456").should eql(true)
-      subject.validate("EE6786784560").should eql(false)
-      subject.validate("EE67867845").should eql(false)
-      subject.validate("EE67867845K").should eql(false)
+      expect(subject.validate("EE678678456")).to eql(true)
+      expect(subject.validate("EE6786784560")).to eql(false)
+      expect(subject.validate("EE67867845")).to eql(false)
+      expect(subject.validate("EE67867845K")).to eql(false)
     end
 
     it "validates a FI vat number" do
-      subject.validate("FI67845638").should eql(true)
+      expect(subject.validate("FI67845638")).to eql(true)
 
-      subject.validate("FI678456389").should eql(false)
-      subject.validate("FI6784563").should eql(false)
-      subject.validate("FI6784563K").should eql(false)
+      expect(subject.validate("FI678456389")).to eql(false)
+      expect(subject.validate("FI6784563")).to eql(false)
+      expect(subject.validate("FI6784563K")).to eql(false)
     end
 
     it "validates a FR vat number" do
-      subject.validate("FR99123543267").should eql(true)
-      subject.validate("FRBB123543267").should eql(true)
-      subject.validate("FR9B123543267").should eql(true)
-      subject.validate("FRB9123543267").should eql(true)
-
-      subject.validate("FR99123543267B").should eql(false)
-      subject.validate("FRBB12354326").should eql(false)
-      subject.validate("FR9B123543F67").should eql(false)
-      subject.validate("FRB9123543").should eql(false)
+      expect(subject.validate("FR99123543267")).to eql(true)
+      expect(subject.validate("FRBB123543267")).to eql(true)
+      expect(subject.validate("FR9B123543267")).to eql(true)
+      expect(subject.validate("FRB9123543267")).to eql(true)
+
+      expect(subject.validate("FR99123543267B")).to eql(false)
+      expect(subject.validate("FRBB12354326")).to eql(false)
+      expect(subject.validate("FR9B123543F67")).to eql(false)
+      expect(subject.validate("FRB9123543")).to eql(false)
     end
 
     it "validates a EL vat number" do
-      subject.validate("EL678456345").should eql(true)
+      expect(subject.validate("EL678456345")).to eql(true)
 
-      subject.validate("EL67845634").should eql(false)
-      subject.validate("EL6784563459").should eql(false)
-      subject.validate("EL67845634P").should eql(false)
+      expect(subject.validate("EL67845634")).to eql(false)
+      expect(subject.validate("EL6784563459")).to eql(false)
+      expect(subject.validate("EL67845634P")).to eql(false)
     end
 
     it "validates a HU vat number" do
-      subject.validate("HU67894595").should eql(true)
+      expect(subject.validate("HU67894595")).to eql(true)
 
-      subject.validate("HU6789459").should eql(false)
-      subject.validate("HU67894595L").should eql(false)
-      subject.validate("HU6789459J").should eql(false)
+      expect(subject.validate("HU6789459")).to eql(false)
+      expect(subject.validate("HU67894595L")).to eql(false)
+      expect(subject.validate("HU6789459J")).to eql(false)
     end
 
     it "validates a HR vat number" do
-      subject.validate("HR12345678912").should eql(true)
+      expect(subject.validate("HR12345678912")).to eql(true)
 
-      subject.validate("HR6789459").should eql(false)
-      subject.validate("HR67894595L").should eql(false)
-      subject.validate("HR6789459J").should eql(false)
+      expect(subject.validate("HR6789459")).to eql(false)
+      expect(subject.validate("HR67894595L")).to eql(false)
+      expect(subject.validate("HR6789459J")).to eql(false)
     end
 
     it "validates a IE vat number" do
-      subject.validate("IE1B12345J").should eql(true)
-      subject.validate("IE1234567B").should eql(true)
-      subject.validate("IE1234567XX").should eql(true)
-
-      subject.validate("IE1B123459").should eql(false)
-      subject.validate("IE19123450").should eql(false)
-      subject.validate("IEA9123450").should eql(false)
-      subject.validate("IE1B12345XX").should eql(false)
-      subject.validate("IE1X34567XX").should eql(false)
+      expect(subject.validate("IE1B12345J")).to eql(true)
+      expect(subject.validate("IE1234567B")).to eql(true)
+      expect(subject.validate("IE1234567XX")).to eql(true)
+
+      expect(subject.validate("IE1B123459")).to eql(false)
+      expect(subject.validate("IE19123450")).to eql(false)
+      expect(subject.validate("IEA9123450")).to eql(false)
+      expect(subject.validate("IE1B12345XX")).to eql(false)
+      expect(subject.validate("IE1X34567XX")).to eql(false)
     end
 
     it "validates a IT vat number" do
-      subject.validate("IT45875359285").should eql(true)
+      expect(subject.validate("IT45875359285")).to eql(true)
 
-      subject.validate("IT458753592859").should eql(false)
-      subject.validate("IT4587535928G").should eql(false)
-      subject.validate("IT4587535928").should eql(false)
+      expect(subject.validate("IT458753592859")).to eql(false)
+      expect(subject.validate("IT4587535928G")).to eql(false)
+      expect(subject.validate("IT4587535928")).to eql(false)
     end
 
     it "validates a LV vat number" do
-      subject.validate("LV85678368906").should eql(true)
+      expect(subject.validate("LV85678368906")).to eql(true)
 
-      subject.validate("LV8567836890").should eql(false)
-      subject.validate("LV856783689066").should eql(false)
-      subject.validate("LV8567836890S").should eql(false)
+      expect(subject.validate("LV8567836890")).to eql(false)
+      expect(subject.validate("LV856783689066")).to eql(false)
+      expect(subject.validate("LV8567836890S")).to eql(false)
     end
 
     it "validates a LT vat number" do
-      subject.validate("LT678678987").should eql(true)
-      subject.validate("LT678678987956").should eql(true)
-
-      subject.validate("LT67867898").should eql(false)
-      subject.validate("LT6786789870").should eql(false)
-      subject.validate("LT678678987K").should eql(false)
-      subject.validate("LT67867898709").should eql(false)
-      subject.validate("LT6786789870C").should eql(false)
-      subject.validate("LT67867898795H").should eql(false)
+      expect(subject.validate("LT678678987")).to eql(true)
+      expect(subject.validate("LT678678987956")).to eql(true)
+
+      expect(subject.validate("LT67867898")).to eql(false)
+      expect(subject.validate("LT6786789870")).to eql(false)
+      expect(subject.validate("LT678678987K")).to eql(false)
+      expect(subject.validate("LT67867898709")).to eql(false)
+      expect(subject.validate("LT6786789870C")).to eql(false)
+      expect(subject.validate("LT67867898795H")).to eql(false)
     end
 
     it "validates a LU vat number" do
-      subject.validate("LU45679456").should eql(true)
+      expect(subject.validate("LU45679456")).to eql(true)
 
-      subject.validate("LU4567945").should eql(false)
-      subject.validate("LU456794560").should eql(false)
-      subject.validate("LU4567945J").should eql(false)
+      expect(subject.validate("LU4567945")).to eql(false)
+      expect(subject.validate("LU456794560")).to eql(false)
+      expect(subject.validate("LU4567945J")).to eql(false)
     end
 
     it "validates a MT vat number" do
-      subject.validate("MT64569367").should eql(true)
+      expect(subject.validate("MT64569367")).to eql(true)
 
-      subject.validate("MT6456936").should eql(false)
-      subject.validate("MT645693679").should eql(false)
-      subject.validate("MT6456936L").should eql(false)
+      expect(subject.validate("MT6456936")).to eql(false)
+      expect(subject.validate("MT645693679")).to eql(false)
+      expect(subject.validate("MT6456936L")).to eql(false)
     end
 
     it "validates a NL vat number" do
-      subject.validate("NL673739491B77").should eql(true)
+      expect(subject.validate("NL673739491B77")).to eql(true)
 
-      subject.validate("NL673739491977").should eql(false)
-      subject.validate("NL673739491A77").should eql(false)
-      subject.validate("NL673739491B771").should eql(false)
-      subject.validate("NL673739491B7").should eql(false)
-      subject.validate("NL6737394917B7").should eql(false)
+      expect(subject.validate("NL673739491977")).to eql(false)
+      expect(subject.validate("NL673739491A77")).to eql(false)
+      expect(subject.validate("NL673739491B771")).to eql(false)
+      expect(subject.validate("NL673739491B7")).to eql(false)
+      expect(subject.validate("NL6737394917B7")).to eql(false)
     end
 
     it "validates a PL vat number" do
-      subject.validate("PL6784567284").should eql(true)
+      expect(subject.validate("PL6784567284")).to eql(true)
 
-      subject.validate("PL678456728").should eql(false)
-      subject.validate("PL67845672849").should eql(false)
-      subject.validate("PL678456728K").should eql(false)
+      expect(subject.validate("PL678456728")).to eql(false)
+      expect(subject.validate("PL67845672849")).to eql(false)
+      expect(subject.validate("PL678456728K")).to eql(false)
     end
 
     it "validates a PT vat number" do
-      subject.validate("PT346296476").should eql(true)
+      expect(subject.validate("PT346296476")).to eql(true)
 
-      subject.validate("PT34629647").should eql(false)
-      subject.validate("PT3462964769").should eql(false)
+      expect(subject.validate("PT34629647")).to eql(false)
+      expect(subject.validate("PT3462964769")).to eql(false)
     end
 
     it "validates a GB vat number" do
-      subject.validate("GB123456789").should eql(true)
-      subject.validate("GB123456789012").should eql(true)
-      subject.validate("GBGD123").should eql(true)
-      subject.validate("GBHA123").should eql(true)
-
-      subject.validate("GB12345678").should eql(false)
-      subject.validate("GB1234567890").should eql(false)
-      subject.validate("GB12345678901").should eql(false)
-      subject.validate("GB1234567890123").should eql(false)
-      subject.validate("GBAB123").should eql(false)
-      subject.validate("GBAA123").should eql(false)
-      subject.validate("GBHH123").should eql(false)
-      subject.validate("GBGD1234").should eql(false)
-      subject.validate("GBGD12").should eql(false)
+      expect(subject.validate("GB123456789")).to eql(true)
+      expect(subject.validate("GB123456789012")).to eql(true)
+      expect(subject.validate("GBGD123")).to eql(true)
+      expect(subject.validate("GBHA123")).to eql(true)
+
+      expect(subject.validate("GB12345678")).to eql(false)
+      expect(subject.validate("GB1234567890")).to eql(false)
+      expect(subject.validate("GB12345678901")).to eql(false)
+      expect(subject.validate("GB1234567890123")).to eql(false)
+      expect(subject.validate("GBAB123")).to eql(false)
+      expect(subject.validate("GBAA123")).to eql(false)
+      expect(subject.validate("GBHH123")).to eql(false)
+      expect(subject.validate("GBGD1234")).to eql(false)
+      expect(subject.validate("GBGD12")).to eql(false)
     end
 
     it "validates a RO vat number" do
-      subject.validate("RO1234567890").should eql(true)
-      subject.validate("RO123456789").should eql(true)
-      subject.validate("RO12345678").should eql(true)
-      subject.validate("RO1234567").should eql(true)
-      subject.validate("RO123456").should eql(true)
-      subject.validate("RO12345").should eql(true)
-      subject.validate("RO1234").should eql(true)
-      subject.validate("RO123").should eql(true)
-      subject.validate("RO12").should eql(true)
-
-      subject.validate("RO1").should eql(false)
-      subject.validate("RO0234567890").should eql(false)
-      subject.validate("RO023456789").should eql(false)
-      subject.validate("RO02345678").should eql(false)
-      subject.validate("RO0234567").should eql(false)
-      subject.validate("RO023456").should eql(false)
-      subject.validate("RO02345").should eql(false)
-      subject.validate("RO0234").should eql(false)
-      subject.validate("RO023").should eql(false)
-      subject.validate("RO02").should eql(false)
-      subject.validate("RO12345678901").should eql(false)
+      expect(subject.validate("RO1234567890")).to eql(true)
+      expect(subject.validate("RO123456789")).to eql(true)
+      expect(subject.validate("RO12345678")).to eql(true)
+      expect(subject.validate("RO1234567")).to eql(true)
+      expect(subject.validate("RO123456")).to eql(true)
+      expect(subject.validate("RO12345")).to eql(true)
+      expect(subject.validate("RO1234")).to eql(true)
+      expect(subject.validate("RO123")).to eql(true)
+      expect(subject.validate("RO12")).to eql(true)
+
+      expect(subject.validate("RO1")).to eql(false)
+      expect(subject.validate("RO0234567890")).to eql(false)
+      expect(subject.validate("RO023456789")).to eql(false)
+      expect(subject.validate("RO02345678")).to eql(false)
+      expect(subject.validate("RO0234567")).to eql(false)
+      expect(subject.validate("RO023456")).to eql(false)
+      expect(subject.validate("RO02345")).to eql(false)
+      expect(subject.validate("RO0234")).to eql(false)
+      expect(subject.validate("RO023")).to eql(false)
+      expect(subject.validate("RO02")).to eql(false)
+      expect(subject.validate("RO12345678901")).to eql(false)
     end
 
     it "validates a SK vat number" do
-      subject.validate("SK5683075682").should eql(true)
+      expect(subject.validate("SK5683075682")).to eql(true)
 
-      subject.validate("SK56830756821").should eql(false)
-      subject.validate("SK568307568").should eql(false)
+      expect(subject.validate("SK56830756821")).to eql(false)
+      expect(subject.validate("SK568307568")).to eql(false)
     end
 
     it "validates a SI vat number" do
-      subject.validate("SI74357893").should eql(true)
+      expect(subject.validate("SI74357893")).to eql(true)
 
-      subject.validate("SI743578931").should eql(false)
-      subject.validate("SI7435789").should eql(false)
+      expect(subject.validate("SI743578931")).to eql(false)
+      expect(subject.validate("SI7435789")).to eql(false)
     end
 
     it "validates a SE vat number" do
-      subject.validate("SE567396352701").should eql(true)
+      expect(subject.validate("SE567396352701")).to eql(true)
 
-      subject.validate("SE56739635201").should eql(false)
-      subject.validate("SE5673963527701").should eql(false)
-      subject.validate("SE567396352702").should eql(false)
-      subject.validate("SE567396352711").should eql(false)
+      expect(subject.validate("SE56739635201")).to eql(false)
+      expect(subject.validate("SE5673963527701")).to eql(false)
+      expect(subject.validate("SE567396352702")).to eql(false)
+      expect(subject.validate("SE567396352711")).to eql(false)
     end
 
     it "validates a CZ vat number" do
-      subject.validate("CZ56389267").should eql(true)
-      subject.validate("CZ563892670").should eql(true)
-      subject.validate("CZ5638926790").should eql(true)
+      expect(subject.validate("CZ56389267")).to eql(true)
+      expect(subject.validate("CZ563892670")).to eql(true)
+      expect(subject.validate("CZ5638926790")).to eql(true)
 
-      subject.validate("CZ5638926").should eql(false)
-      subject.validate("CZ56389268901").should eql(false)
+      expect(subject.validate("CZ5638926")).to eql(false)
+      expect(subject.validate("CZ56389268901")).to eql(false)
     end
 
     it "returns false on blank/non-sense vat number" do
-      subject.validate("").should eql(false)
-      subject.validate(" ").should eql(false)
-      subject.validate("DE").should eql(false)
-      subject.validate("atu123xyz").should eql(false)
-      subject.validate("xxxxxxxxxx").should eql(false)
-      subject.validate("BEFR").should eql(false)
+      expect(subject.validate("")).to eql(false)
+      expect(subject.validate(" ")).to eql(false)
+      expect(subject.validate("DE")).to eql(false)
+      expect(subject.validate("atu123xyz")).to eql(false)
+      expect(subject.validate("xxxxxxxxxx")).to eql(false)
+      expect(subject.validate("BEFR")).to eql(false)
     end
 
     it "allows Valvat instance as input" do
-      subject.validate(Valvat.new("DE345889003")).should eql(true)
-      subject.validate(Valvat.new("DE34588900X")).should eql(false)
+      expect(subject.validate(Valvat.new("DE345889003"))).to eql(true)
+      expect(subject.validate(Valvat.new("DE34588900X"))).to eql(false)
     end
   end
 end