valvat 1.4.1 → 1.4.4

data/README.md

@@ -1,350 +0,0 @@
-valvat
-===========
-
-[![rubygems](https://badgen.net/rubygems/v/valvat)](https://rubygems.org/gems/valvat) [![Specs](https://github.com/yolk/valvat/workflows/Specs/badge.svg)](https://github.com/yolk/valvat/actions?query=workflow%3ASpecs)
-
-Validates european vat numbers. Standalone or as a ActiveModel validator.
-
-## A note on Brexit
-
-Valvat supports validating VAT-IDs from the UK by syntax, checksum and using the HMRC API (for backwards compatibility only with the `:uk` option set to true). Validation against the VIES web service stopped working early 2021.
-
-Northern Ireland received its own VAT number prefix - XI which is supported by VIES web service so any XI-prefixed VAT numbers should be validated as any EU VAT number.
-
-## Features
-
-* Simple syntax verification
-* Lookup via the VIES web service
-* (Optional) lookup via the HMRC web service (for UK VAT numbers)
-* ActiveModel/Rails integration
-* Works standalone without ActiveModel
-* Minimal runtime dependencies
-* I18n locales for language specific error messages in English, German, French, Spanish, Italian, Portuguese, Polish, Swedish, Dutch, Danish, Czech, Slovakian, Hungarian, Bulgarian, Romanian, Latvian, Catalan, Norwegian, and Finnish.
-* *Experimental* checksum verification
-
-valvat is tested and works with ruby MRI 2.6/2.7/3.0/3.1/3.2, jruby and ActiveModel 5/6/7. If you need support for ruby down to 1.9.3 and ActiveModel 3 and 4 use [v1.0.1](https://github.com/yolk/valvat/tree/v1.0.1).
-
-## Installation
-
-Add it to your Gemfile:
-
-```ruby
-gem 'valvat'
-```
-
-And run:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install valvat
-
-## Validate the syntax of a VAT number
-
-To verify the syntax of a vat number:
-
-```ruby
-Valvat.new("DE345789003").valid?
-# => true or false
-```
-
-It is also possible to bypass initializing a Valvat instance and check the syntax of a vat number string directly with:
-
-```ruby
-Valvat::Syntax.validate("DE345789003")
-# => true or false
-```
-
-## Validate against the VIES / HMRC web service
-
-To check if the given vat number exists via the VIES or HMRC web service:
-
-```ruby
-Valvat.new("DE345789003").exists?
-# => true or false or nil
-```
-
-Or to lookup a vat number string directly:
-
-```ruby
-Valvat::Lookup.validate("DE345789003")
-# => true or false or nil
-```
-
-To keep backwards compatibility lookups of UK VAT numbers against the HMRC API are only performed with the option `:uk` set to true.
-
-```ruby
-Valvat::Lookup.validate("GB553557881", uk: true)
-# => true or false or nil
-```
-
-Without this option the lookup of UK VAT number always returns `false`.
-
-*IMPORTANT* Keep in mind that the web service might be offline at some time for all or some member states. If this happens `exists?` or `Valvat::Lookup.validate` will return `nil`. See *Handling of maintenance errors* for further details.
-
-### Details & request identifier
-
-If you need all details and not only if the VAT is valid, pass {detail: true} as second parameter to the lookup call.
-
-```ruby
-Valvat.new("IE6388047V").exists?(detail: true)
-=> {
-  :country_code=> "IE", :vat_number => "6388047V", :valid => true,
-  :request_date => Date.today, :name=> "GOOGLE IRELAND LIMITED",
-  :address=> "1ST & 2ND FLOOR ,GORDON HOUSE ,BARROW STREET ,DUBLIN 4"
-} or false or nil
-```
-
-According to EU law, or at least as Austria sees it, it's mandatory to verify the VAT number of every new customer, but also to check the VAT number periodicaly. To prove that you have checked the VAT number, the web service can return a `request_identifier`.
-
-To receive a `request_identifier` you need to pass your own VAT number in the options hash. In this example, Google (VAT IE6388047V) is checking the validity of eBays VAT number (LU21416127)
-
-```ruby
-Valvat.new("LU21416127").exists?(requester: "IE6388047V")
-=> {
-  :country_code=>"LU", :vat_number => "21416127", :valid => true,
-  :request_date => Date.today, :name=>"EBAY EUROPE S.A R.L.",
-  :address => "22, BOULEVARD ROYAL\nL-2449  LUXEMBOURG",
-  :company_type => nil, :request_identifier => "some_uniq_string"
-} or false or nil
-```
-
-If the given `requester` is invalid, a `Valvat::InvalidRequester` error is thrown.
-
-When requesting a `request_identifier` for a GB VAT number, the requester must be your own GB number; a EU VAT number won't work.
-
-Note that when validating UK VAT numbers using the HMRC service, the detail output is modified to match the one from VIES more closely with slight differences remaining:
-
-1. The `request_date` will actually be a (more precise) `Time` instead of a `Date`
-2. The `address` string will join lines using `\n` instead of `,` so it's more acurate and can be displayed nicely.
-
-### Handling of maintenance errors
-
-From time to time the VIES web service for one or all member states is down for maintenance. To handle this kind of temporary errors, `Valvat::Lookup#validate` returns `nil` by default to indicate that there is no way at the moment to say if the given VAT is valid or not. You should revalidate the VAT later. If you prefer an error, use the `raise_error` option:
-
-```ruby
-Valvat.new("IE6388047V").exists?(raise_error: true)
-```
-
-This raises `Valvat::ServiceUnavailable` or `Valvat::MemberStateUnavailable` instead of returning `nil`.
-
-Visit [https://ec.europa.eu/taxation_customs/vies/#/help](https://ec.europa.eu/taxation_customs/vies/#/help) for more accurate information at what time the service for a specific member state will be down.
-
-### Handling of other errors
-
-All other errors accuring while validating against the web service are raised and must be handled by you. These include:
-
- * `Valvat::InvalidRequester`
- * `Valvat::BlockedError`
- * `Valvat::RateLimitError`
- * `Valvat::Timeout`
- * all IO errors
-
-If you want to suppress all known error cases. Pass in the `raise_error` option set to `false`:
-
-```ruby
-Valvat.new("IE6388047V").exists?(raise_error: false)
-```
-
-This will return `nil` instead of raising a known error.
-
-### Set options for the Net::HTTP client
-
-Use the `:http` key to set options for the http client. These options are directly passed to `Net::HTTP.start`.
-
-For example to set timeouts:
-
-```ruby
-Valvat.new("IE6388047V").exists?(http: { open_timeout: 10, read_timeout: 10 })
-```
-
-### Skip local validation before lookup
-
-To prevent unnecessary requests, valvat performs a local syntax check before making the request to the web service. If you want to skip this step (for any reason), set the `:skip_local_validation` option to `true`.
-
-## Experimental checksum verification
-
-valvat allows to check vat numbers from AT, BE, BG, DE, DK, ES, FR, FI, GR, IE, IT, LU, NL, PL, PT, SE and SI against a checksum calculation. All other member states will fall back to a basic syntax check:
-
-```ruby
-Valvat.new("DE345789003").valid_checksum?
-# => true or false
-```
-
-These results are more valuable than a simple syntax check, but keep in mind: they can not replace a lookup via VIES or HMRC.
-
-*IMPORTANT* This feature was tested against all vat numbers I could get my hand on, but it is still marked as *experimental* because these calculations are not documented and may return wrong results.
-
-To bypass initializing a Valvat instance:
-
-```ruby
-Valvat::Checksum.validate("DE345789003")
-# => true or false
-```
-
-## Configuration
-
-Instead of passing in the same options again and again, Valvat allows to alter its default configuration. This feature is intended to be used when initializing your application (for example in a Rails initializer file).
-
-```ruby
-Valvat.configure(
-  uk: true,
-  raise_error: true,
-  http: { read_timeout: 5 }
-)
-```
-
-To see all options and the defaults, take a look at [valvat/configuration](https://github.com/yolk/valvat/blob/master/lib/valvat/configuration.rb#L25).
-
-## Usage with ActiveModel / Rails
-
-### Loading
-
-When the valvat gem is required and ActiveModel is already loaded, everything will work fine out of the box. If your load order differs just add
-
-```ruby
-require 'active_model/validations/valvat_validator'
-```
-
-after ActiveModel has been loaded.
-
-### Simple syntax validation
-
-To validate the attribute `vat_number` add this to your model:
-
-```ruby
-class MyModel < ActiveRecord::Base
-  validates :vat_number, valvat: true
-end
-```
-
-### Additional lookup validation
-
-To additionally perform an lookup via VIES:
-
-```ruby
-validates :vat_number, valvat: { lookup: true }
-```
-
-To also perform an lookup via HMRC for UK VAT numbers:
-
-```ruby
-validates :vat_number, valvat: { lookup: { uk: true } }
-```
-
-By default this will validate to true if the web service is down. To fail in this case simply add the `:fail_if_down` option:
-
-```ruby
-validates :vat_number, valvat: { lookup: { fail_if_down: true } }
-```
-
-You can pass in any options accepted by `Valvat::Lookup#validate`:
-
-```ruby
-validates :vat_number, valvat: { lookup: { raise_error: true, http: { read_timeout: 12 } } }
-```
-
-### Additional (and experimental) checksum validation
-
-To additionally perform a checksum validation:
-
-```ruby
-validates :vat_number, valvat: { checksum: true }
-```
-
-### Additional ISO country code validation
-
-If you want the vat number’s (ISO) country to match another country attribute, use the _match_country_ option:
-
-```ruby
-validates :vat_number, valvat: { match_country: :country }
-```
-
-where it is supposed that your model has a method named _country_ which returns the country ISO code you want to match.
-
-### Allow blank
-
-By default blank vat numbers validate to false. To change this add the `:allow_blank` option:
-
-```ruby
-validates :vat_number, valvat: { allow_blank: true }
-```
-
-### Allow vat numbers outside of europe
-
-To allow vat numbers from outside of europe, add something like this to your model (country_code should return a upcase ISO country code):
-
-```ruby
-class MyModel < ActiveRecord::Base
-  validates :vat_number, valvat: true, if: :eu?
-
-  def eu?
-    Valvat::Utils::EU_MEMBER_STATES.include?(country_code)
-  end
-end
-```
-
-## Utilities
-
-To split a vat number into the country code and the remaining chars:
-
-```ruby
-Valvat::Utils.split("ATU345789003")
-# => ["AT", "U345789003"]
-```
-
-or
-
-```ruby
-Valvat.new("ATU345789003").to_a
-# => ["AT", "U345789003"]
-```
-
-Both methods always return an array. If it can not detect the country or the given country is located outside of europe it returns `[nil, nil]`. Please note that this does not strictly return the ISO country code: for greek vat numbers this returns the ISO language code 'EL' instead of the ISO country code 'GR'.
-
-To extract the ISO country code of a given vat number:
-
-```ruby
-Valvat.new("EL7345789003").iso_country_code
-# => "GR"
-```
-
-To extract the vat country code (first two chars in every european vat number):
-
-```ruby
-Valvat.new("EL7345789003").vat_country_code
-# => "EL"
-```
-
-To normalize a vat number:
-
-```ruby
-Valvat::Utils.normalize("atu345789003")
-# => "ATU345789003"
-```
-
-This basically just removes trailing spaces and ensures all chars are uppercase.
-
-## Usage with IPv6
-
-There seems to be a problem when using the VIES service over IPv6. Sadly this is nothing this gem can address. For details and proposed solutions have a look at [this question on StackOverflow](http://stackoverflow.com/questions/15616833/vies-vat-api-soap-error-ipv6). Thanks to George Palmer for bringing up this issue.
-
-## Links
-
-* [VIES web service](http://ec.europa.eu/taxation_customs/vies)
-* [HMRC web service](https://developer.service.hmrc.gov.uk/api-documentation/docs/api/service/vat-registered-companies-api/1.0)
-* [European vat number formats (german)](http://bzst.de/DE/Steuern_International/USt_Identifikationsnummer/Merkblaetter/Aufbau_USt_IdNr.html)
-* [European vat number formats on Wikipedia](http://en.wikipedia.org/wiki/European_Union_Value_Added_Tax)
-
-## Contributions by
-
-https://github.com/yolk/valvat/graphs/contributors
-
-## BlaBla
-
-Copyright (c) 2011-2023 mite GmbH
-
-Beyond that, the implementation is licensed under the MIT License.
-
-Code was originally extracted from our time tracking webapp [mite](https://mite.de/en/).

data/Rakefile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec

data/certs/mite.pem

@@ -1,26 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIEbDCCAtSgAwIBAgIBATANBgkqhkiG9w0BAQsFADA+MRIwEAYDVQQDDAlzZWJh
-c3RpYW4xFDASBgoJkiaJk/IsZAEZFgRtaXRlMRIwEAYKCZImiZPyLGQBGRYCZGUw
-HhcNMjMwNDE5MDkxMzEyWhcNMjQwNDE4MDkxMzEyWjA+MRIwEAYDVQQDDAlzZWJh
-c3RpYW4xFDASBgoJkiaJk/IsZAEZFgRtaXRlMRIwEAYKCZImiZPyLGQBGRYCZGUw
-ggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDAWAF/CaDp0cmY7Q2vAqVn
-TpB3xmKKPNfF1Bh9X3P9pKRBl2iCW+JmqIV+J5Yts9mB+OYKfxjJM7mmQwT8DMf2
-KwYIVISGKooRyXPgGgKepYfSfemizey6soCoejIIEHczsRk/FeKcvwlFrqMymBrF
-QP5XhnF0TEQvg/sG97wt8hHH7FwcNn+m8I88abP7ygVMNNOL18EiPd2b/WqalGp0
-aiN/CyGtJdA766QY/wgeYVEHNszzJ3DD7AYy8PWAwouIqmAmdDx7oHu01yyilIHL
-W1l5fqko8TQ3UZjfQBDn4mwUgXT829E7dtQB5O0pkwB2lSY4L2azuC69nVBv7TsB
-nBBCTKqr4JknuMJ1nwoGmOfgVqhmsuiGtMyabtagPg1DUpoXMYuf/PbhmSsgedgH
-j2nCnREKxACA/A1pG3HyDhYqkeb7VA4M1Fx4s1wHXKZw/pmxCxCbB/w34wwV2OUh
-fOtjTuX5/o5Tza2dIeBaENs8xMjqIX6DshtWbrJwyacCAwEAAaN1MHMwCQYDVR0T
-BAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFLjadA9ioIK4kItaOGJOhPYM/dVJ
-MBwGA1UdEQQVMBOBEXNlYmFzdGlhbkBtaXRlLmRlMBwGA1UdEgQVMBOBEXNlYmFz
-dGlhbkBtaXRlLmRlMA0GCSqGSIb3DQEBCwUAA4IBgQCQtG2K4dDwQhBkCpSgP8sC
-rc8v5siwMa306nG9Bs3c+KbVI8xJM8APqG8y+DUGzx0i+AIE9g5i2c7H9rwXSA9t
-BRTXZ6O7Hjmkn4pUC8Yc2ylNgP9pdpYxqwe6ZVah8DdGW7m/dQwSisKtO+0XFwB8
-rJmI29qalNK4bzk+DOW9pMdIfIHsbFU7pzTcFBux/MzIqQO24A+zcdYIz7MHBucF
-85qF319BKW5/HgZMgxm26obTKJFEMDODYlNmm5ywvQCHSCyJ1yW/IFiCpqhiLm5w
-R8JZvYWO38fAsYF3VowUCmsqOBdaQo+L3aA/NVmhNeh4LddJwjrqY+Duw2Gz+DdP
-VyquPzH92Wc7Etd50IFILEkNV2VvRctuyY5/TAWoLKI9RQGYpKxd4jqZRtZFfODY
-O1ARwPz8pN+xIvxo8ex8Hz1sazm/iFgVBwHgaI3O3ctK7vF4+fAu6dlLcbEpij9z
-4QlUng62OJRSBV/ejaTTItcAOXBeh028ZFWC0QQR4r0=
------END CERTIFICATE-----

data/gemfiles/activemodel-5

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'activemodel', '~> 5.0'
-gem 'rake'
-gem 'rspec', '~> 3.0'
-gem 'webmock', '~> 3.0'
-
-gemspec path: '../'

data/gemfiles/activemodel-6

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'activemodel', '~> 6.0'
-gem 'rake'
-gem 'rspec', '~> 3.0'
-gem 'webmock', '~> 3.0'
-
-gemspec path: '../'

data/gemfiles/activemodel-7

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'activemodel', '~> 7.0'
-gem 'rake'
-gem 'rspec', '~> 3.0'
-gem 'webmock', '~> 3.0'
-
-gemspec path: '../'

data/gemfiles/standalone

@@ -1,7 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'rake'
-gem 'rspec', '~> 3.0'
-gem 'webmock', '~> 3.0'
-
-gemspec path: '../'

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