valvat 1.4.1 → 1.4.4

data/spec/valvat/lookup/hmrc_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Lookup::HMRC do
-  before do
-    stub_const('Valvat::Lookup::HMRC::ENDPOINT_URL', 'https://test-api.service.hmrc.gov.uk/organisations/vat/check-vat-number/lookup')
-  end
-
-  after do
-    Valvat.configure(uk: false)
-  end
-
-  it 'returns hash with valid: true on success' do
-    response = described_class.new('GB553557881', { uk: true }).perform
-
-    expect(response).to match({
-                                valid: true,
-                                address: "131B Barton Hamlet\nSW97 5CK\nGB",
-                                country_code: 'GB',
-                                vat_number: '553557881',
-                                name: 'Credite Sberger Donal Inc.',
-                                request_date: kind_of(Time)
-                              })
-  end
-
-  it 'returns hash with valid: false on invalid input' do
-    response = described_class.new('GB123456789', { uk: true }).perform
-    expect(response).to match({ valid: false })
-  end
-
-  it 'returns hash with valid: false on valid input with :uk option not set' do
-    response = described_class.new('GB553557881', {}).perform
-    expect(response).to match({ valid: false })
-  end
-
-  it 'returns valid: false when uk option is set to false' do
-    response = described_class.new('GB553557881', { uk: false }).perform
-    expect(response).to match({ valid: false })
-  end
-
-  it 'returns valid: false when uk option is not set' do
-    response = described_class.new('GB553557881').perform
-    expect(response).to match({ valid: false })
-  end
-
-  it 'respects global :uk setting' do
-    Valvat.configure(uk: true)
-    response = described_class.new('GB553557881').perform
-    expect(response).to include({ valid: true })
-  end
-
-  it 'overwrite global :uk setting' do
-    Valvat.configure(uk: true)
-    response = described_class.new('GB553557881', uk: false).perform
-    expect(response).to include({ valid: false })
-  end
-end

data/spec/valvat/lookup/vies_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Lookup::VIES do
-  it 'returns hash with valid: true on success' do
-    response = described_class.new('IE6388047V', {}).perform
-
-    skip 'VIES is down' if response[:error].is_a?(Valvat::MemberStateUnavailable)
-
-    expect(response).to match({
-                                valid: true,
-                                address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
-                                country_code: 'IE',
-                                vat_number: '6388047V',
-                                name: 'GOOGLE IRELAND LIMITED',
-                                request_date: kind_of(Date)
-                              })
-  end
-
-  it 'returns hash with valid: false on invalid input' do
-    response = described_class.new('XC123123', {}).perform
-    expect(response.to_hash).to match({ valid: false, faultstring: 'INVALID_INPUT', faultcode: 'env:Server' })
-  end
-end

data/spec/valvat/lookup_spec.rb

@@ -1,493 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Lookup do
-  describe '#validate' do
-    context 'with existing EU VAT number' do
-      it 'returns true' do
-        result = described_class.validate('IE6388047V')
-        skip 'VIES is down' if result.nil?
-        expect(result).to be(true)
-      end
-
-      it 'allows Valvat instance as input' do
-        result = described_class.validate(Valvat.new('IE6388047V'))
-        skip 'VIES is down' if result.nil?
-        expect(result).to be(true)
-      end
-
-      context 'with details' do
-        it 'returns hash of details instead of true' do
-          result = described_class.validate('IE6388047V', detail: true)
-          skip 'VIES is down' if result.nil?
-
-          expect(result).to match({
-                                    request_date: kind_of(Date),
-                                    country_code: 'IE',
-                                    vat_number: '6388047V',
-                                    name: 'GOOGLE IRELAND LIMITED',
-                                    address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
-                                    valid: true
-                                  })
-        end
-      end
-    end
-
-    context 'with existing GB VAT number' do
-      it 'returns true' do
-        result = described_class.validate('GB727255821', uk: true)
-        skip 'HMRC is down' if result.nil?
-        expect(result).to be(true)
-      end
-
-      it 'returns details in format similar to VIES' do
-        result = described_class.validate('GB727255821', detail: true, uk: true)
-        skip 'HMRC is down' if result.nil?
-        expect(result).to match({
-                                  request_date: kind_of(Time),
-                                  country_code: 'GB',
-                                  vat_number: '727255821',
-                                  name: 'AMAZON EU SARL',
-                                  address: "1 PRINCIPAL PLACE\nWORSHIP STREET\nLONDON\nEC2A 2FA\nGB",
-                                  valid: true
-                                })
-      end
-    end
-
-    context 'with not existing EU VAT number' do
-      it 'returns false' do
-        result =  described_class.validate('IE6388048V')
-        skip 'VIES is down' if result.nil?
-        expect(result).to be(false)
-      end
-
-      context 'with details' do
-        it 'still returns false' do
-          result = described_class.validate('LU21416128', detail: true)
-          skip 'VIES is down' if result.nil?
-          expect(result).to be(false)
-        end
-      end
-    end
-
-    context 'with not existing GB VAT number' do
-      it 'returns false' do
-        result =  described_class.validate('GB727255820', uk: true)
-        skip 'HMRC is down' if result.nil?
-        expect(result).to be(false)
-      end
-    end
-
-    context 'with invalid country code / input' do
-      it 'returns false' do
-        expect(described_class.validate('AE259597697')).to be(false)
-        expect(described_class.validate('')).to be(false)
-      end
-    end
-
-    context 'with request identifier' do
-      it 'returns hash of details instead of true' do
-        result = described_class.validate('IE6388047V', requester: 'DE129415943')
-
-        skip 'VIES is down' if result.nil?
-
-        expect(result).to match({
-                                  request_date: kind_of(Date),
-                                  request_identifier: /\A[\w\W]{16}\Z/,
-                                  country_code: 'IE',
-                                  vat_number: '6388047V',
-                                  name: 'GOOGLE IRELAND LIMITED',
-                                  company_type: nil,
-                                  address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
-                                  valid: true
-                                })
-      end
-
-      it 'supports old :requester_vat option for backwards compatibility' do
-        result = described_class.validate('IE6388047V', requester_vat: 'LU21416127')
-
-        skip 'VIES is down' if result.nil?
-
-        expect(result).to match({
-                                  request_date: kind_of(Date),
-                                  request_identifier: /\A[\w\W]{16}\Z/,
-                                  country_code: 'IE',
-                                  vat_number: '6388047V',
-                                  name: 'GOOGLE IRELAND LIMITED',
-                                  company_type: nil,
-                                  address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
-                                  valid: true
-                                })
-      end
-
-      context 'with GB VAT number' do
-        it 'returns hash of details with request number' do
-          response = described_class.validate('GB727255821', requester: 'GB727255821', uk: true)
-          skip 'HMRC is down' if response.nil?
-          expect(response).to match({
-                                      request_date: kind_of(Time),
-                                      request_identifier: /\A\w\w\w-\w\w\w-\w\w\w\Z/,
-                                      country_code: 'GB',
-                                      vat_number: '727255821',
-                                      name: 'AMAZON EU SARL',
-                                      address: "1 PRINCIPAL PLACE\nWORSHIP STREET\nLONDON\nEC2A 2FA\nGB",
-                                      valid: true
-                                    })
-        end
-
-        it 'raises exception if requester is not from GB' do
-          expect do
-            described_class.validate('GB727255821', requester: 'IE6388047V', uk: true)
-          end.to raise_error(Valvat::InvalidRequester,
-                             'The HMRC web service returned the error: ' \
-                             'INVALID_REQUEST (Invalid requesterVrn - Vrn parameters should be 9 or 12 digits)')
-        end
-
-        it 'raises exception if requester is not valid' do
-          expect do
-            described_class.validate('GB727255821', requester: 'GB6388047', uk: true)
-          end.to raise_error(Valvat::InvalidRequester,
-                             'The HMRC web service returned the error: ' \
-                             'INVALID_REQUEST (Invalid requesterVrn - Vrn parameters should be 9 or 12 digits)')
-        end
-      end
-
-      context 'when set in global config' do
-        before { Valvat.configure(requester: 'IE6388047V') }
-        after { Valvat.configure(requester: nil) }
-
-        it 'returns hash of details instead of true' do
-          result = described_class.validate('IE6388047V')
-
-          skip 'VIES is down' if result.nil?
-
-          expect(result).to match({
-                                    request_date: kind_of(Date),
-                                    request_identifier: /\A[\w\W]{16}\Z/,
-                                    country_code: 'IE',
-                                    vat_number: '6388047V',
-                                    name: 'GOOGLE IRELAND LIMITED',
-                                    company_type: nil,
-                                    address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
-                                    valid: true
-                                  })
-        end
-      end
-    end
-  end
-
-  describe '#validate with VIES test enviroment' do
-    let(:options) do
-      { skip_local_validation: true }
-    end
-
-    before do
-      stub_const('Valvat::Lookup::VIES::ENDPOINT_URI', URI('https://ec.europa.eu/taxation_customs/vies/test-services/checkVatTestService'))
-    end
-
-    context 'with valid request with valid VAT number' do
-      subject(:result) { described_class.validate('DE100', options) }
-
-      it 'returns true' do
-        expect(result).to be(true)
-      end
-    end
-
-    context 'with valid request with an invalid VAT number' do
-      subject(:result) { described_class.validate('DE200', options) }
-
-      it 'returns false' do
-        expect(result).to be(false)
-      end
-    end
-
-    describe 'Error : INVALID_INPUT' do
-      subject(:result) { described_class.validate('DE201', options) }
-
-      it 'returns false' do
-        expect(result).to be(false)
-      end
-    end
-
-    describe 'Error : INVALID_REQUESTER_INFO' do
-      subject(:result) { described_class.validate('DE202', options) }
-
-      it 'raises Valvat::InvalidRequester' do
-        expect { result }.to raise_error(Valvat::InvalidRequester)
-      end
-    end
-
-    describe 'Error : SERVICE_UNAVAILABLE' do
-      subject(:result) { described_class.validate('DE300', options) }
-
-      it 'returns nil' do
-        expect(result).to be_nil
-      end
-
-      it 'raises error with raise_error: true' do
-        expect do
-          described_class.validate('DE300', options.merge(raise_error: true))
-        end.to raise_error(Valvat::ServiceUnavailable)
-      end
-    end
-
-    describe 'Error : MS_UNAVAILABLE' do
-      subject(:result) { described_class.validate('DE301', options) }
-
-      it 'returns nil' do
-        expect(result).to be_nil
-      end
-
-      it 'raises error with raise_error: true' do
-        expect do
-          described_class.validate('DE301', options.merge(raise_error: true))
-        end.to raise_error(Valvat::MemberStateUnavailable)
-      end
-    end
-
-    describe 'Error : TIMEOUT' do
-      subject(:result) { described_class.validate('DE302', options) }
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::Timeout)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('DE302', options.merge(raise_error: false))).to be_nil
-      end
-    end
-
-    describe 'Network timeout' do
-      subject(:result) { described_class.validate('DE200', options) }
-
-      before { stub_request(:post, /ec.europa.eu/).to_timeout }
-
-      it 'raises error' do
-        expect { result }.to raise_error(Net::OpenTimeout, 'execution expired')
-      end
-
-      it 'also raises error with raise_error set to false (not handled)' do
-        expect do
-          described_class.validate('DE302', options.merge(raise_error: false))
-        end.to raise_error(Net::OpenTimeout, 'execution expired')
-      end
-    end
-
-    describe 'Error : VAT_BLOCKED' do
-      subject(:result) { described_class.validate('DE400', options) }
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::BlockedError, /VAT_BLOCKED/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('DE400', options.merge(raise_error: false))).to be_nil
-      end
-    end
-
-    describe 'Error : IP_BLOCKED' do
-      subject(:result) { described_class.validate('DE401', options) }
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::BlockedError, /IP_BLOCKED/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('DE401', options.merge(raise_error: false))).to be_nil
-      end
-    end
-
-    describe 'Error : GLOBAL_MAX_CONCURRENT_REQ' do
-      subject(:result) { described_class.validate('DE500', options) }
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::RateLimitError, /GLOBAL_MAX_CONCURRENT_REQ/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('DE500', options.merge(raise_error: false))).to be_nil
-      end
-    end
-
-    describe 'Error : GLOBAL_MAX_CONCURRENT_REQ_TIME' do
-      subject(:result) { described_class.validate('DE501', options) }
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::RateLimitError, /GLOBAL_MAX_CONCURRENT_REQ_TIME/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('DE501', options.merge(raise_error: false))).to be_nil
-      end
-    end
-
-    describe 'Error : MS_MAX_CONCURRENT_REQ' do
-      subject(:result) { described_class.validate('DE600', options) }
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::RateLimitError, /MS_MAX_CONCURRENT_REQ/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('DE600', options.merge(raise_error: false))).to be_nil
-      end
-    end
-
-    describe 'Error : MS_MAX_CONCURRENT_REQ_TIME' do
-      subject(:result) { described_class.validate('DE601', options) }
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::RateLimitError, /MS_MAX_CONCURRENT_REQ_TIME/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('DE601', options.merge(raise_error: false))).to be_nil
-      end
-    end
-
-    describe 'Error : HTTP error' do
-      subject(:result) { described_class.validate('DE601', options) }
-
-      before do
-        stub_request(:post, %r{\Ahttps://ec\.europa\.eu}).to_return({ status: 405 })
-      end
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::HTTPError, 'The VIES web service returned the error: 405')
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('DE601', options.merge(raise_error: false))).to be_nil
-      end
-    end
-  end
-
-  describe '#validate with HMRC test enviroment' do
-    # https://developer.service.hmrc.gov.uk/api-documentation/docs/testing
-    # https://github.com/hmrc/vat-registered-companies-api/blob/master/public/api/conf/1.0/test-data/vrn.csv
-    subject(:result) { described_class.validate('GB123456789', uk: true) }
-
-    before do
-      stub_const('Valvat::Lookup::HMRC::ENDPOINT_URL', 'https://test-api.service.hmrc.gov.uk/organisations/vat/check-vat-number/lookup')
-    end
-
-    context 'with valid request with valid VAT number' do
-      it 'returns true' do
-        expect(described_class.validate('GB553557881', uk: true)).to be(true)
-        expect(described_class.validate('GB146295999727', uk: true)).to be(true)
-      end
-    end
-
-    context 'with valid request with an invalid VAT number' do
-      it 'returns false' do
-        expect(result).to be(false)
-      end
-    end
-
-    describe 'Error : MESSAGE_THROTTLED_OUT' do
-      before do
-        stub_request(:get, /test-api\.service\.hmrc\.gov\.uk/).to_return(
-          status: 429,
-          body: '{"code":"MESSAGE_THROTTLED_OUT"}'
-        )
-      end
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::RateLimitError, /MESSAGE_THROTTLED_OUT/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('GB123456789', raise_error: false, uk: true)).to be_nil
-      end
-    end
-
-    describe 'Error : SCHEDULED_MAINTENANCE' do
-      before do
-        stub_request(:get, /test-api\.service\.hmrc\.gov\.uk/).to_return(
-          status: 503,
-          body: '{"code":"SCHEDULED_MAINTENANCE"}'
-        )
-      end
-
-      it 'returns nil' do
-        expect(result).to be_nil
-      end
-
-      it 'raises error with raise_error set to false' do
-        expect do
-          described_class.validate('GB123456789', raise_error: true, uk: true)
-        end.to raise_error(Valvat::ServiceUnavailable, 'The HMRC web service returned the error: SCHEDULED_MAINTENANCE')
-      end
-    end
-
-    describe 'Error : SERVER_ERROR' do
-      before do
-        stub_request(:get, /test-api\.service\.hmrc\.gov\.uk/).to_return(
-          status: 503,
-          body: '{"code":"SERVER_ERROR"}'
-        )
-      end
-
-      it 'returns nil' do
-        expect(result).to be_nil
-      end
-
-      it 'raises error with raise_error set to false' do
-        expect do
-          described_class.validate('GB123456789', raise_error: true, uk: true)
-        end.to raise_error(Valvat::ServiceUnavailable, 'The HMRC web service returned the error: SERVER_ERROR')
-      end
-    end
-
-    describe 'Error : GATEWAY_TIMEOUT' do
-      before do
-        stub_request(:get, /test-api\.service\.hmrc\.gov\.uk/).to_return(
-          status: 504,
-          body: '{"code":"GATEWAY_TIMEOUT"}'
-        )
-      end
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::Timeout, /GATEWAY_TIMEOUT/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('GB123456789', raise_error: false, uk: true)).to be_nil
-      end
-    end
-
-    describe 'Network timeout' do
-      before do
-        stub_request(:get, /test-api\.service\.hmrc\.gov\.uk/).to_timeout
-      end
-
-      it 'raises error' do
-        expect { result }.to raise_error(Net::OpenTimeout)
-      end
-
-      it 'also raises error with raise_error set to false (not handled)' do
-        expect do
-          described_class.validate('GB123456789', raise_error: false, uk: true)
-        end.to raise_error(Net::OpenTimeout)
-      end
-    end
-
-    describe 'Error : INTERNAL_SERVER_ERROR' do
-      before do
-        stub_request(:get, /test-api\.service\.hmrc\.gov\.uk/).to_return(
-          status: 500,
-          body: '{"code":"INTERNAL_SERVER_ERROR"}'
-        )
-      end
-
-      it 'raises error' do
-        expect { result }.to raise_error(Valvat::UnknownLookupError, /INTERNAL_SERVER_ERROR/)
-      end
-
-      it 'returns nil with raise_error set to false' do
-        expect(described_class.validate('GB123456789', raise_error: false, uk: true)).to be_nil
-      end
-    end
-  end
-end

data/spec/valvat/options_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Options do
-  describe '#[]' do
-    it 'returns global config by default' do
-      expect(described_class.new({})[:uk]).to be(false)
-    end
-
-    it 'returns option if set' do
-      expect(described_class.new({ uk: true })[:uk]).to be(true)
-    end
-
-    context 'when options contains deprecated key' do
-      let(:options) { described_class.new({ requester_vat: 'DE123' }, silence: true) }
-
-      it 'returns it on new key' do
-        expect(options[:requester]).to be('DE123')
-      end
-    end
-  end
-end

data/spec/valvat/syntax_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-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
-
-  invalid_vats.each do |invalid|
-    it "returns false for #{invalid.inspect}" do
-      expect(described_class.validate(invalid)).to be(false)
-    end
-  end
-end
-
-describe Valvat::Syntax do
-  describe '#validate' do
-    it_validates(%w[ATU03458890], %w[ATU034588908 ATU0345908 ATU0345889Y])
-    it_validates(%w[BE0817331995 BE1817331999], %w[BE081733199 BE08173319944 BE081733199H BE2817331999])
-    it_validates(%w[BG468134789 BG4681347897], %w[BG46813478979 BG4681347897C BG46813478G BG46813478])
-    it_validates(%w[CY36579347A CY36579347C CY60000347C], %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 IT00146089990], %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