valvat 1.4.1 → 1.4.2

data/spec/active_model/validations/valvat_validator_spec.rb

@@ -1,274 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-if defined?(ActiveModel)
-  class Invoice < ModelBase
-    validates :vat_number, valvat: true
-  end
-
-  class InvoiceWithLookup < ModelBase
-    validates :vat_number, valvat: { lookup: true }
-  end
-
-  class InvoiceWithLookupAndFailIfDown < ModelBase
-    validates :vat_number, valvat: { lookup: :fail_if_down }
-  end
-
-  class InvoiceAllowBlank < ModelBase
-    validates :vat_number, valvat: { allow_blank: true }
-  end
-
-  class InvoiceAllowBlankOnAll < ModelBase
-    validates :vat_number, valvat: true, allow_blank: true
-  end
-
-  class InvoiceCheckCountry < ModelBase
-    validates :vat_number, valvat: { match_country: :country }
-
-    def country
-      @attributes[:country]
-    end
-  end
-
-  class InvoiceCheckCountryWithLookup < ModelBase
-    validates :vat_number, valvat: { match_country: :country, lookup: true }
-
-    def country
-      @attributes[:country]
-    end
-  end
-
-  class InvoiceWithChecksum < ModelBase
-    validates :vat_number, valvat: { checksum: true }
-  end
-
-  describe Invoice do
-    before do
-      I18n.locale = :en
-    end
-
-    context 'with valid VAT number' do
-      it 'is valid' do
-        expect(described_class.new(vat_number: 'DE259597697')).to be_valid
-      end
-    end
-
-    context 'with invalid VAT number' do
-      let(:invoice) { described_class.new(vat_number: 'DE259597697123') }
-
-      it 'is not valid' do
-        expect(invoice).not_to be_valid
-      end
-
-      it 'adds default (country specific) error message' do
-        invoice.valid?
-        expect(invoice.errors[:vat_number]).to eql(['is not a valid German VAT number'])
-      end
-
-      context 'with DE locale' do
-        before do
-          I18n.locale = :de
-        end
-
-        it 'adds translated error message' do
-          invoice.valid?
-          expect(invoice.errors[:vat_number]).to eql(['ist keine gültige deutsche USt-IdNr.'])
-        end
-      end
-
-      context 'with PT locale' do
-        before do
-          I18n.locale = :pt
-        end
-
-        it 'adds translated error message' do
-          invoice.valid?
-          expect(invoice.errors[:vat_number]).to eql(['O NIF alemão não é válido.'])
-        end
-      end
-
-      context 'with i18n translation in place' do
-        before do
-          I18n.backend.store_translations(:en, activemodel: {
-                                            errors: { models: { invoice: { invalid_vat: 'is ugly.' } } }
-                                          })
-        end
-
-        after { I18n.reload! }
-
-        it 'uses translation' do
-          invoice.valid?
-          expect(invoice.errors[:vat_number]).to eql(['is ugly.'])
-        end
-      end
-
-      context 'with i18n translation with country_adjective placeholder in place' do
-        before do
-          msg = 'is not a %{country_adjective} vat' # rubocop:disable Style/FormatStringToken
-          translation = { activemodel: { errors: { models: { invoice: { invalid_vat: msg } } } } }
-          I18n.backend.store_translations(:en, translation)
-        end
-
-        after { I18n.reload! }
-
-        it 'replaces country_adjective placeholder' do
-          invoice = described_class.new(vat_number: 'IE123')
-          invoice.valid?
-          expect(invoice.errors[:vat_number]).to eql(['is not a Irish vat'])
-        end
-
-        it "falls back to 'European' if country is missing" do
-          invoice = described_class.new(vat_number: 'XX123')
-          invoice.valid?
-          expect(invoice.errors[:vat_number]).to eql(['is not a European vat'])
-        end
-      end
-    end
-
-    context 'with blank VAT number' do
-      it 'is not valid' do
-        expect(described_class.new(vat_number: '')).not_to be_valid
-        expect(described_class.new(vat_number: nil)).not_to be_valid
-      end
-    end
-  end
-
-  describe InvoiceWithLookup do
-    context 'with valid but not existing VAT number' do
-      before do
-        allow(Valvat::Syntax).to receive_messages(validate: true)
-        allow(Valvat::Lookup).to receive_messages(validate: false)
-      end
-
-      it 'is not valid' do
-        expect(described_class.new(vat_number: 'DE123')).not_to be_valid
-      end
-    end
-
-    context 'with valid and existing VAT number' do
-      before do
-        allow(Valvat::Syntax).to receive_messages(validate: true)
-        allow(Valvat::Lookup).to receive_messages(validate: true)
-      end
-
-      it 'is valid' do
-        expect(described_class.new(vat_number: 'DE123')).to be_valid
-      end
-    end
-
-    context 'with valid VAT number and VIES country service down' do
-      before do
-        allow(Valvat::Syntax).to receive_messages(validate: true)
-        allow(Valvat::Lookup).to receive_messages(validate: nil)
-      end
-
-      it 'is valid' do
-        expect(described_class.new(vat_number: 'DE123')).to be_valid
-      end
-    end
-  end
-
-  describe InvoiceWithLookupAndFailIfDown do
-    let(:record) { described_class.new }
-
-    context 'with valid VAT number and VIES country service down' do
-      before do
-        allow(Valvat::Syntax).to receive_messages(validate: true)
-        allow(Valvat::Lookup).to receive_messages(validate: nil)
-      end
-
-      it 'is not valid' do
-        expect(record).not_to be_valid
-        msg = 'Unable to validate your VAT number: the VIES service is down. Please try again later.'
-        expect(record.errors[:vat_number]).to eql([msg])
-      end
-    end
-  end
-
-  describe InvoiceAllowBlank do
-    context 'with blank VAT number' do
-      it 'is valid' do
-        expect(described_class.new(vat_number: '')).to be_valid
-        expect(described_class.new(vat_number: nil)).to be_valid
-      end
-    end
-  end
-
-  describe InvoiceAllowBlankOnAll do
-    context 'with blank VAT number' do
-      it 'is valid' do
-        expect(described_class.new(vat_number: '')).to be_valid
-        expect(described_class.new(vat_number: nil)).to be_valid
-      end
-    end
-  end
-
-  describe InvoiceCheckCountry do
-    it 'is not valid on blank country' do
-      expect(described_class.new(country: nil, vat_number: 'DE259597697')).not_to be_valid
-      expect(described_class.new(country: '', vat_number: 'DE259597697')).not_to be_valid
-    end
-
-    it 'is not valid on wired country' do
-      expect(described_class.new(country: 'XAXXX', vat_number: 'DE259597697')).not_to be_valid
-      expect(described_class.new(country: 'ZO', vat_number: 'DE259597697')).not_to be_valid
-    end
-
-    it 'is not valid on mismatching (eu) country' do
-      expect(described_class.new(country: 'FR', vat_number: 'DE259597697')).not_to be_valid
-      expect(described_class.new(country: 'AT', vat_number: 'DE259597697')).not_to be_valid
-      expect(described_class.new(country: 'DE', vat_number: 'ATU65931334')).not_to be_valid
-    end
-
-    it 'is valid on matching country' do
-      expect(described_class.new(country: 'DE', vat_number: 'DE259597697')).to be_valid
-      expect(described_class.new(country: 'AT', vat_number: 'ATU65931334')).to be_valid
-    end
-
-    it 'gives back error message with country from :country_match' do
-      invoice = described_class.new(country: 'FR', vat_number: 'DE259597697')
-      invoice.valid?
-      expect(invoice.errors[:vat_number]).to eql(['is not a valid French VAT number'])
-    end
-
-    it 'gives back error message with country from :country_match even on invalid VAT number' do
-      invoice = described_class.new(country: 'FR', vat_number: 'DE259597697123')
-      invoice.valid?
-      expect(invoice.errors[:vat_number]).to eql(['is not a valid French VAT number'])
-    end
-  end
-
-  describe InvoiceCheckCountryWithLookup do
-    before do
-      allow(Valvat::Syntax).to receive_messages(validate: true)
-      allow(Valvat::Lookup).to receive_messages(validate: true)
-    end
-
-    it 'avoids lookup or syntax check on failed because of mismatching country' do
-      described_class.new(country: 'FR', vat_number: 'DE259597697').valid?
-      expect(Valvat::Syntax).not_to have_received(:validate)
-      expect(Valvat::Lookup).not_to have_received(:validate)
-    end
-
-    it 'check syntax and looup on matching country' do
-      described_class.new(country: 'DE', vat_number: 'DE259597697').valid?
-      expect(Valvat::Syntax).to have_received(:validate)
-      expect(Valvat::Lookup).to have_received(:validate)
-    end
-  end
-
-  describe InvoiceWithChecksum do
-    context 'with valid VAT number' do
-      it 'is valid' do
-        expect(described_class.new(vat_number: 'DE259597697')).to be_valid
-      end
-    end
-
-    context 'with invalid VAT number' do
-      it 'is not valid' do
-        expect(described_class.new(vat_number: 'DE259597687')).not_to be_valid
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec'
-begin
-  require 'active_model'
-rescue LoadError
-  puts 'Running specs without active_model extension'
-end
-
-require "#{File.dirname(__FILE__)}/../lib/valvat.rb"
-require 'webmock/rspec'
-WebMock.allow_net_connect!
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-  config.filter_run focus: true
-  config.run_all_when_everything_filtered = true
-end
-
-I18n.enforce_available_locales = false if defined?(I18n)
-
-if defined?(ActiveModel)
-  class ModelBase
-    include ActiveModel::Serialization
-    include ActiveModel::Validations
-
-    attr_accessor :attributes
-
-    def initialize(attributes = {})
-      @attributes = attributes
-    end
-
-    def read_attribute_for_validation(key)
-      @attributes[key]
-    end
-  end
-end

data/spec/valvat/checksum/at_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::AT do
-  %w[ATU13585627 ATU66059506 ATU42403001].each do |valid_vat|
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to be(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
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-end

data/spec/valvat/checksum/be_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-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
-      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
-    end
-
-    invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
-
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-end

data/spec/valvat/checksum/bg_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-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
-      expect(Valvat::Checksum.validate(valid_vat)).to be(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
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-end

data/spec/valvat/checksum/cy_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::CY do
-  %w[CY01234567U CY00532445O].each do |valid_vat|
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to be 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
-      expect(Valvat::Checksum.validate(invalid_vat)).to be false
-    end
-  end
-end

data/spec/valvat/checksum/de_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-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
-      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
-    end
-
-    invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
-
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-end

data/spec/valvat/checksum/dk_spec.rb

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

data/spec/valvat/checksum/ee_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::EE do
-  %w[EE101234568 EE100207415].each do |valid_vat|
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to be true
-    end
-
-    invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
-
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be false
-    end
-  end
-end

data/spec/valvat/checksum/es_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::ES do
-  %w[ESA13585625 ESB83871236 ESE54507058 ES25139013J ESQ1518001A ESQ5018001G ESX4942978W ESX7676464F ESB10317980
-     ESY3860557K ESY2207765D ES28350472M ES41961720Z ESM1171170X ESK0928769Y ES50095545G].each do |valid_vat|
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to be(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
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-
-  describe 'if starts with [KLMXYZ\\d], is always a natural person' do
-    invalid_vat = 'ESX65474207'
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-
-  describe 'some CIF categories (NPQRSW) require control-digit to be a letter' do
-    invalid_vat = 'ESP65474207'
-    valid_vat = 'ESP6547420G'
-
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
-    end
-  end
-
-  describe 'some CIF categories (CDFGJNUV) allow both a numeric check digit and a letter' do
-    %w[ESC65474207 ESC6547420G].each do |valid_vat|
-      it "returns true on valid VAT #{valid_vat}" do
-        expect(Valvat::Checksum.validate(valid_vat)).to be(true)
-      end
-    end
-  end
-
-  describe 'applies special rules to validation' do
-    describe 'special NIF categories (KLM) require CD to be a letter and first two digits ' \
-             'to be between 01 and 56 (inclusive)' do
-      %w[ESK8201230M ESK0001230B].each do |invalid_vat|
-        it "returns false on invalid VAT #{invalid_vat}" do
-          expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-        end
-      end
-    end
-
-    describe 'arbitrarily invalid VATs' do
-      %w[ESX0000000T ES00000001R ES00000000T ES99999999R].each do |invalid_vat|
-        it "returns false on invalid VAT #{invalid_vat}" do
-          expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-        end
-      end
-    end
-  end
-end

data/spec/valvat/checksum/fi_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-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
-      expect(Valvat::Checksum.validate(valid_vat)).to be(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
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-end

data/spec/valvat/checksum/fr_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::FR do
-  %w[FR60528551658 FR43820567501 FR0H384498879].each do |valid_vat|
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
-    end
-
-    invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
-
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-end

data/spec/valvat/checksum/gb_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::GB do
-  %w[GBGD100 GBHA600].each do |gov_agency_vat|
-    it "returns true on valid VAT for government agency #{gov_agency_vat}" do
-      expect(Valvat::Checksum.validate(gov_agency_vat)).to be true
-    end
-  end
-
-  %w[GB000000000 GB000000000000].each do |invalid_vat|
-    it 'is false for all zero number' do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be false
-    end
-  end
-
-  it 'is true for an old format valid vat' do
-    expect(Valvat::Checksum.validate('GB434031494')).to be true
-  end
-
-  it 'is true for a new format valid vat' do
-    expect(Valvat::Checksum.validate('GB434031439')).to be true
-    expect(Valvat::Checksum.validate('GB727255821')).to be true
-  end
-
-  it 'is false for an old format VAT in forbidden group' do
-    expect(Valvat::Checksum.validate('GB999999973')).to be false
-  end
-
-  it 'is false for a new format VAT in forbidden group' do
-    expect(Valvat::Checksum.validate('GB100000034')).to be false
-  end
-end

data/spec/valvat/checksum/gr_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-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
-      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
-    end
-
-    invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
-
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-end

data/spec/valvat/checksum/hr_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::HR do
-  %w[HR06282943396 HR17099025134].each do |valid_vat|
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to be true
-    end
-
-    invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
-
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be false
-    end
-  end
-end

data/spec/valvat/checksum/hu_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::HU do
-  %w[HU10672101 HU13460370 HU10747759].each do |valid_vat|
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to be true
-    end
-
-    invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
-
-    it "returns false on invalid VAT #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to be false
-    end
-  end
-end

data/spec/valvat/checksum/ie_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Checksum::IE do
-  %w[IE8473625E IE0123459N IE9B12345N IE1113571MH IE2973912UH IE2974611LH
-     IE2974901UH IE3200115LH IE3206791MH IE3208913KH IE3214048CH].each do |valid_vat|
-    it "returns true on valid VAT #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to eql(true), valid_vat
-    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
-      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
-    end
-  end
-
-  %w[IE0000000XX IE0000000AZ].each do |invalid|
-    it "returns false on invalid VAT #{invalid}" do
-      expect(Valvat::Checksum.validate(invalid)).to be(false)
-    end
-  end
-end

data/spec/valvat/checksum/it_spec.rb

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