valvat 1.0.1 → 1.1.0

data/spec/valvat/syntax_spec.rb

@@ -1,289 +1,68 @@
-require 'spec_helper'
-
-describe Valvat::Syntax do
-  describe "#validate" do
-    it "validates a DE VAT number" do
-      expect(subject.validate("DE345889003")).to eql(true)
-
-      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
-      expect(subject.validate("ATU03458890")).to eql(true)
-
-      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
-      expect(subject.validate("BE0817331995")).to eql(true)
-
-      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
-      expect(subject.validate("BG468134789")).to eql(true)
-      expect(subject.validate("BG4681347897")).to eql(true)
-
-      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
-      expect(subject.validate("CY36579347A")).to eql(true)
-      expect(subject.validate("CY36579347C")).to eql(true)
-
-      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
-      expect(subject.validate("DK67893463")).to eql(true)
-
-      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
-      expect(subject.validate("ESX67345987")).to eql(true)
-      expect(subject.validate("ESA6734598B")).to eql(true)
-      expect(subject.validate("ES56734598C")).to eql(true)
-
-      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
-      expect(subject.validate("EE100207415")).to eql(true)
-      expect(subject.validate("EE1002074150")).to eql(false)
-      expect(subject.validate("EE10020741")).to eql(false)
-      expect(subject.validate("EE100207415K")).to eql(false)
-    end
-
-    it "validates a FI VAT number" do
-      expect(subject.validate("FI67845638")).to eql(true)
-
-      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
-      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
-      expect(subject.validate("EL678456345")).to eql(true)
-
-      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
-      expect(subject.validate("HU67894595")).to eql(true)
-
-      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
-      expect(subject.validate("HR12345678912")).to eql(true)
-
-      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
-      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
-      expect(subject.validate("IT45875359285")).to eql(true)
+# frozen_string_literal: true
 
-      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
-      expect(subject.validate("LV85678368906")).to eql(true)
-
-      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
-      expect(subject.validate("LT213179412")).to eql(true)
-      expect(subject.validate("LT290061371314")).to eql(true)
-
-      expect(subject.validate("LT21317942")).to eql(false)
-      expect(subject.validate("LT213179422")).to eql(false)
-      expect(subject.validate("LT2131794120")).to eql(false)
-      expect(subject.validate("LT213179412K")).to eql(false)
-      expect(subject.validate("LT29006137132")).to eql(false)
-      expect(subject.validate("LT290061371324")).to eql(false)
-      expect(subject.validate("LT29006137131C")).to eql(false)
-      expect(subject.validate("LT290061371314H")).to eql(false)
-    end
-
-    it "validates a LU VAT number" do
-      expect(subject.validate("LU45679456")).to eql(true)
-
-      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
-      expect(subject.validate("MT64569367")).to eql(true)
-
-      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
-      expect(subject.validate("NL673739491B77")).to eql(true)
-
-      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
-      expect(subject.validate("PL6784567284")).to eql(true)
-
-      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
-      expect(subject.validate("PT346296476")).to eql(true)
-
-      expect(subject.validate("PT34629647")).to eql(false)
-      expect(subject.validate("PT3462964769")).to eql(false)
-    end
-
-    it "validates a GB VAT number" do
-      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
-      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
-      expect(subject.validate("SK5683075682")).to eql(true)
-
-      expect(subject.validate("SK56830756821")).to eql(false)
-      expect(subject.validate("SK568307568")).to eql(false)
-    end
-
-    it "validates a SI VAT number" do
-      expect(subject.validate("SI74357893")).to eql(true)
-
-      expect(subject.validate("SI743578931")).to eql(false)
-      expect(subject.validate("SI7435789")).to eql(false)
-    end
-
-    it "validates a SE VAT number" do
-      expect(subject.validate("SE567396352701")).to eql(true)
-
-      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
-      expect(subject.validate("CZ56389267")).to eql(true)
-      expect(subject.validate("CZ563892670")).to eql(true)
-      expect(subject.validate("CZ5638926790")).to eql(true)
+require 'spec_helper'
 
-      expect(subject.validate("CZ5638926")).to eql(false)
-      expect(subject.validate("CZ56389268901")).to eql(false)
+def it_validates(valid_vats, invalid_vats)
+  valid_vats.each do |valid|
+    it "returns true for #{valid.inspect}" do
+      expect(described_class.validate(valid)).to be(true)
     end
+  end
 
-    it "returns false on blank/non-sense VAT number" do
-      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)
+  invalid_vats.each do |invalid|
+    it "returns false for #{invalid.inspect}" do
+      expect(described_class.validate(invalid)).to be(false)
     end
+  end
+end
 
-    it "allows Valvat instance as input" do
-      expect(subject.validate(Valvat.new("DE345889003"))).to eql(true)
-      expect(subject.validate(Valvat.new("DE34588900X"))).to eql(false)
+describe Valvat::Syntax do
+  describe '#validate' do
+    it_validates(%w[ATU03458890], %w[ATU034588908 ATU0345908 ATU0345889Y])
+    it_validates(%w[BE0817331995], %w[BE081733199 BE08173319944 BE081733199H BE1817331999])
+    it_validates(%w[BG468134789 BG4681347897], %w[BG46813478979 BG4681347897C BG46813478G BG46813478])
+    it_validates(%w[CY36579347A CY36579347C], %w[CY36579347 CY365793478 CY365793478A CY365793G])
+    it_validates(%w[CZ56389267 CZ563892670 CZ5638926790], %w[CZ5638926 CZ56389268901])
+    it_validates(%w[DE345889003], %w[DE34588900 DE3458890090 DE34588900C])
+    it_validates(%w[DK67893463], %w[DK678934637 DK6789346 DK6789346H])
+    it_validates(%w[EE100207415], %w[EE1002074150 EE10020741 EE10020741 EE100207415K])
+    it_validates(%w[EL678456345], %w[EL67845634 EL6784563459 EL67845634P])
+    it_validates(%w[ESX67345987 ESA6734598B ES56734598C], %w[ES167345987 ESX6734598 ESX673459890])
+    it_validates(%w[FI67845638], %w[FI678456389 FI6784563 FI6784563K])
+    it_validates(%w[FR99123543267 FRBB123543267 FR9B123543267 FRB9123543267],
+                 %w[FR99123543267B FRBB12354326 FR9B123543F67 FRB9123543])
+    it_validates(%w[GB123456789 GB123456789012 GBGD123 GBHA123],
+                 %w[GB12345678 GB1234567890 GB12345678901 GB1234567890123 GBAB123 GBAA123 GBHH123 GBGD1234 GBGD12])
+    it_validates(%w[HR12345678912], %w[HR6789459 HR67894595L HR6789459J])
+    it_validates(%w[HU67894595], %w[HU6789459 HU67894595L HU6789459J])
+    it_validates(%w[IE1B12345J IE1234567B IE1234567XX], %w[IE1B123459 IE19123450 IEA9123450 IE1B12345XX IE1X34567XX])
+    it_validates(%w[IT45875359285], %w[IT458753592859 IT4587535928G IT4587535928])
+    it_validates(%w[LT213179412 LT290061371314],
+                 %w[LT21317942 LT213179422 LT2131794120 LT213179412K LT29006137132 LT290061371324 LT29006137131C
+                    LT290061371314H])
+    it_validates(%w[LU45679456], %w[LU4567945 LU456794560 LU4567945J])
+    it_validates(%w[LV85678368906], %w[LV8567836890 LV856783689066 LV8567836890S])
+    it_validates(%w[MT64569367], %w[MT6456936 MT645693679 MT6456936L])
+    it_validates(%w[NL673739491B77], %w[NL673739491977 NL673739491A77 NL673739491B771 NL673739491B7 NL6737394917B7])
+    it_validates(%w[PL6784567284], %w[PL678456728 PL67845672849 PL678456728K])
+    it_validates(%w[PT346296476], %w[PT34629647 PT3462964769])
+    it_validates(%w[RO1234567890 RO123456789 RO12345678 RO1234567 RO123456 RO12345 RO1234 RO123 RO12],
+                 %w[RO1 RO0234567890 RO023456789 RO02345678 RO0234567 RO023456 RO02345 RO0234 RO02 RO12345678901])
+    it_validates(%w[SE567396352701], %w[SE56739635201 SE5673963527701 SE567396352702 SE567396352711])
+    it_validates(%w[SI74357893], %w[SI743578931 SI7435789])
+    it_validates(%w[SK5683075682], %w[SK56830756821 SK568307568])
+    it_validates(%w[XI123456789 XI123456789012 XIGD123 XIHA123],
+                 %w[XI12345678 XI12345678901234 XIGD1234 XIHA1234 XIGD12 XIHA12 XIHD123])
+
+    it 'returns false on blank/non-sense VAT number' do
+      ['', ' ', 'DE', 'atu123xyz', 'xxxxxxxxxx', 'BEFR'].each do |input|
+        expect(described_class.validate(input)).to be(false)
+      end
+    end
+
+    it 'allows Valvat instance as input' do
+      expect(described_class.validate(Valvat.new('DE345889003'))).to be(true)
+      expect(described_class.validate(Valvat.new('DE34588900X'))).to be(false)
     end
   end
 end

data/spec/valvat/utils_spec.rb

@@ -1,97 +1,112 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Utils do
-  describe "#split" do
-    it "returns country and rest on VAT number as array" do
-      expect(Valvat::Utils.split("DE345889003")).to eql(["DE", "345889003"])
-      expect(Valvat::Utils.split("ESX4588900X")).to eql(["ES", "X4588900X"])
+  describe '#split' do
+    it 'returns country and rest on VAT number as array' do
+      expect(described_class.split('DE345889003')).to eql(%w[DE 345889003])
+      expect(described_class.split('ESX4588900X')).to eql(%w[ES X4588900X])
+    end
+
+    it 'returns two nils on non-european iso codes as array' do
+      expect(described_class.split('US345889003')).to eql([nil, nil])
+      expect(described_class.split('RUX4588900X')).to eql([nil, nil])
     end
 
-    it "returns two nils on non-european iso codes as array" do
-      expect(Valvat::Utils.split("US345889003")).to eql([nil, nil])
-      expect(Valvat::Utils.split("RUX4588900X")).to eql([nil, nil])
+    it 'returns two nils on non-sense input as array' do
+      expect(described_class.split('DE')).to eql([nil, nil])
+      expect(described_class.split('X345889003')).to eql([nil, nil])
+      expect(described_class.split('')).to eql([nil, nil])
+      expect(described_class.split('1234')).to eql([nil, nil])
+      expect(described_class.split(' ')).to eql([nil, nil]) # rubocop:disable Style/RedundantArgument
     end
 
-    it "returns two nils on non-sense input as array" do
-      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])
+    it 'returns EL (language iso code) on greek vat' do
+      expect(described_class.split('EL999999999')).to eql(%w[EL 999999999])
     end
 
-    it "returns EL (language iso code) on greek vat" do
-      expect(Valvat::Utils.split("EL999999999")).to eql(["EL", "999999999"])
+    it 'returns XI (vat number code) on northern ireland vat' do
+      expect(described_class.split('XI999999999')).to eql(%w[XI 999999999])
     end
   end
 
-  describe "#normalize" do
-    it "returns VAT number with upcase chars" do
-      expect(Valvat::Utils.normalize("de345889003")).to eql("DE345889003")
-      expect(Valvat::Utils.normalize("EsX4588900y")).to eql("ESX4588900Y")
+  describe '#normalize' do
+    it 'returns VAT number with upcase chars' do
+      expect(described_class.normalize('de345889003')).to eql('DE345889003')
+      expect(described_class.normalize('EsX4588900y')).to eql('ESX4588900Y')
     end
 
-    it "returns trimmed VAT number" do
-      expect(Valvat::Utils.normalize(" DE345889003")).to eql("DE345889003")
-      expect(Valvat::Utils.normalize("  DE345889003  ")).to eql("DE345889003")
-      expect(Valvat::Utils.normalize("DE345889003 ")).to eql("DE345889003")
+    it 'returns trimmed VAT number' do
+      expect(described_class.normalize(' DE345889003')).to eql('DE345889003')
+      expect(described_class.normalize('  DE345889003  ')).to eql('DE345889003')
+      expect(described_class.normalize('DE345889003 ')).to eql('DE345889003')
     end
 
-    it "does not change already normalized VAT numbers" do
-      expect(Valvat::Utils.normalize("DE345889003")).to eql("DE345889003")
-      expect(Valvat::Utils.normalize("ESX4588900X")).to eql("ESX4588900X")
+    it 'does not change already normalized VAT numbers' do
+      expect(described_class.normalize('DE345889003')).to eql('DE345889003')
+      expect(described_class.normalize('ESX4588900X')).to eql('ESX4588900X')
     end
 
-    it "removes spaces" do
-      expect(Valvat::Utils.normalize("DE 345889003")).to eql("DE345889003")
-      expect(Valvat::Utils.normalize("ESX  458 8900 X")).to eql("ESX4588900X")
+    it 'removes spaces' do
+      expect(described_class.normalize('DE 345889003')).to eql('DE345889003')
+      expect(described_class.normalize('ESX  458 8900 X')).to eql('ESX4588900X')
     end
 
-    it "removes special chars" do
-      expect(Valvat::Utils.normalize("DE.345-889_00:3,;")).to eql("DE345889003")
-      expect(Valvat::Utils.normalize("→ DE·Ö34588 9003\0 ☺")).to eql("→DEÖ345889003☺")
+    it 'removes special chars' do
+      expect(described_class.normalize('DE.345-889_00:3,;')).to eql('DE345889003')
+      expect(described_class.normalize("→ DE·Ö34588 9003\0 ☺")).to eql('→DEÖ345889003☺')
     end
   end
 
-  describe "#vat_country_to_iso_country" do
+  describe '#vat_country_to_iso_country' do
     it "returns iso country code on greek iso language 'EL'" do
-      expect(Valvat::Utils.vat_country_to_iso_country("EL")).to eql("GR")
+      expect(described_class.vat_country_to_iso_country('EL')).to eql('GR')
+    end
+
+    it "returns iso country code on northern ireland vat prefix 'XI'" do
+      expect(described_class.vat_country_to_iso_country('XI')).to eql('GB')
     end
 
     Valvat::Utils::EU_MEMBER_STATES.each do |iso|
       it "returns unchanged iso country code '#{iso}'" do
-        expect(Valvat::Utils.vat_country_to_iso_country(iso)).to eql(iso)
+        expect(described_class.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
-      expect(Valvat::Utils.iso_country_to_vat_country("GR")).to eql("EL")
+  describe '#iso_country_to_vat_country' do
+    it "returns VAT country EL on greek iso country code 'GR'" do
+      expect(described_class.iso_country_to_vat_country('GR')).to eql('EL')
+    end
+
+    it "returns VAT country XI on british iso country code 'GB'" do
+      expect(described_class.iso_country_to_vat_country('GB')).to eql('XI')
     end
 
     Valvat::Utils::EU_MEMBER_STATES.each do |c|
+      next if c == 'GR'
+
       it "returns unchanged VAT country code '#{c}'" do
-        expect(Valvat::Utils.iso_country_to_vat_country(c)).to eql(c)
-      end unless c == "GR"
+        expect(described_class.iso_country_to_vat_country(c)).to eql(c)
+      end
     end
   end
 
-  describe "#country_is_supported?" do
+  describe '#country_is_supported?' do
     Valvat::Utils::EU_MEMBER_STATES.each do |code|
       it "returns true on #{code}" do
-        expect(Valvat::Utils.country_is_supported?(code)).to eql(true)
+        expect(described_class.country_is_supported?(code)).to be(true)
       end
     end
 
-    it "returns true on GB" do
-      expect(Valvat::Utils.country_is_supported?("GB")).to eql(true)
+    it 'returns true on GB' do
+      expect(described_class.country_is_supported?('GB')).to be(true)
     end
 
-    ["US", "AE", "CA", "CN", "BR", "AU", "NO", "ML"].each do |code|
+    %w[US AE CA CN BR AU NO ML].each do |code|
       it "returns false on #{code}" do
-        expect(Valvat::Utils.country_is_supported?(code)).to eql(false)
+        expect(described_class.country_is_supported?(code)).to be(false)
       end
     end
   end