valvat 0.9.1 → 1.1.0

data/lib/valvat/locales/hu.yml

@@ -2,6 +2,7 @@ hu:
   errors:
     messages:
       invalid_vat: a közösségi adószám %{country_adjective} helytelen
+      vies_down: "Az adószám ellenőrzése sikertelen: a VIES szolgáltatás nem elérhető. Kérjük próbálja újra később."
   valvat:
     country_adjectives:
       eu: európai

data/lib/valvat/locales/nl.yml

@@ -2,6 +2,7 @@ nl:
   errors:
     messages:
       invalid_vat: is geen geldig %{country_adjective} btw nummer
+      vies_down: "We kunnen uw btw-nummer niet bevestigen: de VIES-service is momenteel niet beschikbaar. Probeer het later opnieuw."
   valvat:
     country_adjectives:
       eu: Europees

data/lib/valvat/locales/pl.yml

@@ -2,6 +2,7 @@ pl:
   errors:
     messages:
       invalid_vat: nie jest prawidłowym %{country_adjective} numerem VAT
+      vies_down: "Nie można zweryfikować numeru VAT: serwis VIES nie działa. Spróbuj ponownie później."
   valvat:
     country_adjectives:
       eu: europejskim

data/lib/valvat/locales/pt.yml

@@ -4,31 +4,31 @@ pt:
       invalid_vat: O NIF %{country_adjective} não é válido.
   valvat:
     country_adjectives:
-    eu: europeu
-    at: austríaco
-    be: belga
-    bg: búlgaro
-    cy: cipriota
-    cz: checo
-    de: alemão
-    dk: dinamarquês
-    ee: estónio
-    es: espanhol
-    fi: finlandês
-    fr: francês
-    gb: britânico
-    gr: grego
-    hu: húngaro
-    ie: irlandês
-    it: italiano
-    lt: lituano
-    lu: luxemburguês
-    lv: letão
-    mt: maltês
-    nl: holandês
-    pl: polaco
-    pt: português
-    ro: romeno
-    se: sueco
-    si: esloveno
-    sk: eslovaco
+      eu: europeu
+      at: austríaco
+      be: belga
+      bg: búlgaro
+      cy: cipriota
+      cz: checo
+      de: alemão
+      dk: dinamarquês
+      ee: estónio
+      es: espanhol
+      fi: finlandês
+      fr: francês
+      gb: britânico
+      gr: grego
+      hu: húngaro
+      ie: irlandês
+      it: italiano
+      lt: lituano
+      lu: luxemburguês
+      lv: letão
+      mt: maltês
+      nl: holandês
+      pl: polaco
+      pt: português
+      ro: romeno
+      se: sueco
+      si: esloveno
+      sk: eslovaco

data/lib/valvat/lookup.rb

@@ -1,36 +1,24 @@
-require 'savon'
+# frozen_string_literal: true
 
 class Valvat
   class Lookup
-    VIES_WSDL_URL = 'http://ec.europa.eu/taxation_customs/vies/checkVatService.wsdl'
-    REMOVE_KEYS = [:valid, :@xmlns]
-
-    attr_reader :vat, :options
-
-    def initialize(vat, options={})
+    def initialize(vat, options = {})
       @vat = Valvat(vat)
       @options = options || {}
-      @options[:requester_vat] = Valvat(requester_vat) if requester_vat
+      @options[:requester] ||= @options[:requester_vat]
     end
 
     def validate
-      return false unless vat.european?
+      return false if !@options[:skip_local_validation] && !@vat.valid?
+      return handle_vies_error(response[:error]) if response[:error]
 
-      valid? && show_details? ? response_details : valid?
-    rescue => error
-      return false if invalid_input?(error)
-      raise error  if options[:raise_error]
-      nil
+      response[:valid] && show_details? ? response.to_hash : response[:valid]
     end
 
     class << self
-      def validate(vat, options={})
+      def validate(vat, options = {})
         new(vat, options).validate
       end
-
-      def client
-        @client ||= Savon::Client.new(wsdl: VIES_WSDL_URL, log: false, follow_redirects: true)
-      end
     end
 
     private
@@ -40,37 +28,18 @@ class Valvat
     end
 
     def response
-      @response ||= request.perform(self.class.client)
-    end
-
-    def request
-      if requester_vat
-        RequestWithId.new(vat, requester_vat)
-      else
-        Request.new(vat)
-      end
-    end
-
-    def requester_vat
-      options[:requester_vat]
-    end
-
-    def invalid_input?(err)
-      return if !err.respond_to?(:to_hash) || !err.to_hash[:fault]
-      (err.to_hash[:fault][:faultstring] || "").upcase =~ /INVALID_INPUT/
+      @response ||= Request.new(@vat, @options).perform
     end
 
     def show_details?
-      requester_vat || options[:detail]
+      @options[:requester] || @options[:detail]
     end
 
-    def response_details
-      response.inject({}) do |hash, kv|
-        key, value = kv
-        unless REMOVE_KEYS.include?(key)
-          hash[key.to_s.sub(/^trader_/, "").to_sym] = (value == "---" ? nil : value)
-        end
-        hash
+    def handle_vies_error(error)
+      if error.is_a?(ViesMaintenanceError)
+        raise error if @options[:raise_error]
+      else
+        raise error unless @options[:raise_error] == false
       end
     end
   end

data/lib/valvat/lookup/fault.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Valvat
+  class Lookup
+    class Fault < Response
+      def self.cleanup(hash)
+        fault = hash[:fault][:faultstring]
+        return { valid: false } if fault == 'INVALID_INPUT'
+
+        { error: fault_to_error(fault) }
+      end
+
+      FAULTS = {
+        'SERVICE_UNAVAILABLE' => ServiceUnavailable,
+        'MS_UNAVAILABLE' => MemberStateUnavailable,
+        'INVALID_REQUESTER_INFO' => InvalidRequester,
+        'TIMEOUT' => Timeout,
+        'VAT_BLOCKED' => BlockedError,
+        'IP_BLOCKED' => BlockedError,
+        'GLOBAL_MAX_CONCURRENT_REQ' => RateLimitError,
+        'GLOBAL_MAX_CONCURRENT_REQ_TIME' => RateLimitError,
+        'MS_MAX_CONCURRENT_REQ' => RateLimitError,
+        'MS_MAX_CONCURRENT_REQ_TIME' => RateLimitError
+      }.freeze
+
+      def self.fault_to_error(fault)
+        (FAULTS[fault] || UnknownViesError).new(fault)
+      end
+    end
+  end
+end

data/lib/valvat/lookup/request.rb

@@ -1,31 +1,57 @@
+# frozen_string_literal: true
+
+require 'savon'
+
 class Valvat
   class Lookup
     class Request
-      def initialize(vat)
-        @vat = vat
+      VIES_WSDL_URL = 'https://ec.europa.eu/taxation_customs/vies/checkVatService.wsdl'
+
+      def initialize(vat, options)
+        @vat = Valvat(vat)
+        @options = options || {}
+        @requester = @options[:requester] && Valvat(@options[:requester])
       end
 
-      def perform(client)
-        client.call(action, :message => body, :message_tag => message_tag).to_hash[response_key]
+      def perform
+        Response.new(
+          client.call(action, message: message, message_tag: message_tag)
+        )
+      rescue Savon::SOAPFault => e
+        Fault.new(e)
       end
 
       private
 
-      def body
-        {:country_code => @vat.vat_country_code, :vat_number => @vat.to_s_wo_country}
+      def client
+        Savon::Client.new({
+          wsdl: VIES_WSDL_URL, log: false, follow_redirects: true
+        }.merge(@options[:savon] || {}))
+      end
+
+      def message
+        add_requester({
+                        country_code: @vat.vat_country_code,
+                        vat_number: @vat.to_s_wo_country
+                      })
       end
 
       def message_tag
-        :checkVat
+        @requester ? :checkVatApprox : :checkVat
       end
 
       def action
-        :check_vat
+        @requester ? :check_vat_approx : :check_vat
       end
 
-      def response_key
-        :check_vat_response
+      def add_requester(message)
+        return message unless @requester
+
+        message[:requester_country_code] = @requester.vat_country_code
+        message[:requester_vat_number]   = @requester.to_s_wo_country
+
+        message
       end
     end
   end
-end
+end

data/lib/valvat/lookup/response.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Valvat
+  class Lookup
+    class Response
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def [](key)
+        to_hash[key]
+      end
+
+      def to_hash
+        @to_hash ||= self.class.cleanup(@raw.to_hash)
+      end
+
+      def self.cleanup(hash)
+        (
+          hash[:check_vat_approx_response] || hash[:check_vat_response] || {}
+        ).each_with_object({}) do |(key, value), result|
+          result[cleanup_key(key)] = cleanup_value(value) unless key == :"@xmlns"
+        end
+      end
+
+      TRADER_PREFIX = /\Atrader_/.freeze
+
+      def self.cleanup_key(key)
+        key.to_s.sub(TRADER_PREFIX, '').to_sym
+      end
+
+      def self.cleanup_value(value)
+        value == '---' ? nil : value
+      end
+    end
+  end
+end

data/lib/valvat/syntax.rb

@@ -1,36 +1,37 @@
+# frozen_string_literal: true
+
 class Valvat
   module Syntax
-
     VAT_PATTERNS = {
-        'AT' => /\AATU[0-9]{8}\Z/,                                          # Austria
-        'BE' => /\ABE0[0-9]{9}\Z/,                                          # Belgium
-        'BG' => /\ABG[0-9]{9,10}\Z/,                                        # Bulgaria
-        'CY' => /\ACY(?!12)[0-59][0-9]{7}[A-Z]\Z/,                          # Cyprus
-        'CZ' => /\ACZ[0-9]{8,10}\Z/,                                        # Czech Republic
-        'DE' => /\ADE[0-9]{9}\Z/,                                           # Germany
-        'DK' => /\ADK[0-9]{8}\Z/,                                           # Denmark
-        'EE' => /\AEE10[0-9]{7}\Z/,                                         # Estonia
-        'GR' => /\AEL[0-9]{9}\Z/,                                           # Greece
-        'ES' => /\AES([A-Z][0-9]{8}|[0-9]{8}[A-Z]|[A-Z][0-9]{7}[A-Z])\Z/,   # Spain
-        'FI' => /\AFI[0-9]{8}\Z/,                                           # Finland
-        'FR' => /\AFR[A-Z0-9]{2}[0-9]{9}\Z/,                                # France
-        'GB' => /\AGB([0-9]{9}|[0-9]{12}|(HA|GD)[0-9]{3})\Z/,               # United Kingdom
-        'HR' => /\AHR[0-9]{11}\Z/,                                          # Croatia
-        'HU' => /\AHU[0-9]{8}\Z/,                                           # Hungary
-        'IE' => /\AIE([0-9][A-Z][0-9]{5}|[0-9]{7}[A-Z]?)[A-Z]\Z/,           # Ireland
-        'IT' => /\AIT[0-9]{11}\Z/,                                          # Italy
-        'LT' => /\ALT([0-9]{7}1[0-9]|[0-9]{10}1[0-9])\Z/,                   # Lithuania
-        'LU' => /\ALU[0-9]{8}\Z/,                                           # Luxembourg
-        'LV' => /\ALV[0-9]{11}\Z/,                                          # Latvia
-        'MT' => /\AMT[0-9]{8}\Z/,                                           # Malta
-        'NL' => /\ANL[0-9]{9}B[0-9]{2}\Z/,                                  # Netherlands
-        'PL' => /\APL[0-9]{10}\Z/,                                          # Poland
-        'PT' => /\APT[0-9]{9}\Z/,                                           # Portugal
-        'RO' => /\ARO[1-9][0-9]{1,9}\Z/,                                    # Romania
-        'SE' => /\ASE[0-9]{10}01\Z/,                                        # Sweden
-        'SI' => /\ASI[0-9]{8}\Z/,                                           # Slovenia
-        'SK' => /\ASK[0-9]{10}\Z/                                           # Slovakia
-      }
+      'AT' => /\AATU[0-9]{8}\Z/,                                          # Austria
+      'BE' => /\ABE0[0-9]{9}\Z/,                                          # Belgium
+      'BG' => /\ABG[0-9]{9,10}\Z/,                                        # Bulgaria
+      'CY' => /\ACY(?!12)[0-59][0-9]{7}[A-Z]\Z/,                          # Cyprus
+      'CZ' => /\ACZ[0-9]{8,10}\Z/,                                        # Czech Republic
+      'DE' => /\ADE[0-9]{9}\Z/,                                           # Germany
+      'DK' => /\ADK[0-9]{8}\Z/,                                           # Denmark
+      'EE' => /\AEE10[0-9]{7}\Z/,                                         # Estonia
+      'GR' => /\AEL[0-9]{9}\Z/,                                           # Greece
+      'ES' => /\AES([A-Z][0-9]{8}|[0-9]{8}[A-Z]|[A-Z][0-9]{7}[A-Z])\Z/,   # Spain
+      'FI' => /\AFI[0-9]{8}\Z/,                                           # Finland
+      'FR' => /\AFR[A-Z0-9]{2}[0-9]{9}\Z/,                                # France
+      'GB' => /\A(GB|XI)([0-9]{9}|[0-9]{12}|(HA|GD)[0-9]{3})\Z/,          # United Kingdom
+      'HR' => /\AHR[0-9]{11}\Z/,                                          # Croatia
+      'HU' => /\AHU[0-9]{8}\Z/,                                           # Hungary
+      'IE' => /\AIE([0-9][A-Z][0-9]{5}|[0-9]{7}[A-Z]?)[A-Z]\Z/,           # Ireland
+      'IT' => /\AIT[0-9]{11}\Z/,                                          # Italy
+      'LT' => /\ALT([0-9]{7}1[0-9]|[0-9]{10}1[0-9])\Z/,                   # Lithuania
+      'LU' => /\ALU[0-9]{8}\Z/,                                           # Luxembourg
+      'LV' => /\ALV[0-9]{11}\Z/,                                          # Latvia
+      'MT' => /\AMT[0-9]{8}\Z/,                                           # Malta
+      'NL' => /\ANL[0-9]{9}B[0-9]{2}\Z/,                                  # Netherlands
+      'PL' => /\APL[0-9]{10}\Z/,                                          # Poland
+      'PT' => /\APT[0-9]{9}\Z/,                                           # Portugal
+      'RO' => /\ARO[1-9][0-9]{1,9}\Z/,                                    # Romania
+      'SE' => /\ASE[0-9]{10}01\Z/,                                        # Sweden
+      'SI' => /\ASI[0-9]{8}\Z/,                                           # Slovenia
+      'SK' => /\ASK[0-9]{10}\Z/                                           # Slovakia
+    }.freeze
 
     def self.validate(vat)
       vat = Valvat(vat)

data/lib/valvat/utils.rb

@@ -1,27 +1,38 @@
+# frozen_string_literal: true
+
+require 'date'
+
 class Valvat
   module Utils
-
-    EU_COUNTRIES = %w(AT BE BG CY CZ DE DK EE ES FI FR GB GR HR HU IE IT LT LU LV MT NL PL PT RO SE SI SK)
-    COUNTRY_PATTERN = /\A([A-Z]{2})(.+)\Z/
-    NORMALIZE_PATTERN = /[[:space:][:punct:][:cntrl:]]+/
+    EU_MEMBER_STATES = %w[AT BE BG CY CZ DE DK EE ES FI FR GR HR HU IE IT LT LU LV MT NL PL PT RO SE SI SK].freeze
+    SUPPORTED_STATES = EU_MEMBER_STATES + %w[GB]
+    EU_COUNTRIES = EU_MEMBER_STATES # TODO: Remove constant
+    COUNTRY_PATTERN = /\A([A-Z]{2})(.+)\Z/.freeze
+    NORMALIZE_PATTERN = /[[:space:][:punct:][:cntrl:]]+/.freeze
+    CONVERT_VAT_TO_ISO_COUNTRY = { 'EL' => 'GR', 'XI' => 'GB' }.freeze
+    CONVERT_ISO_TO_VAT_COUNTRY = CONVERT_VAT_TO_ISO_COUNTRY.invert.freeze
 
     def self.split(vat)
       COUNTRY_PATTERN =~ vat
-      result = [$1, $2]
+      result = [Regexp.last_match(1), Regexp.last_match(2)]
       iso_country = vat_country_to_iso_country(result[0])
-      EU_COUNTRIES.include?(iso_country) ? result : [nil, nil]
+      country_is_supported?(iso_country) ? result : [nil, nil]
     end
 
     def self.normalize(vat)
-      vat.to_s.upcase.gsub(NORMALIZE_PATTERN, "")
+      vat.to_s.upcase.gsub(NORMALIZE_PATTERN, '')
     end
 
     def self.vat_country_to_iso_country(vat_country)
-      vat_country == "EL" ? "GR" : vat_country
+      CONVERT_VAT_TO_ISO_COUNTRY[vat_country] || vat_country
     end
 
     def self.iso_country_to_vat_country(iso_country)
-      iso_country == "GR" ? "EL" : iso_country
+      CONVERT_ISO_TO_VAT_COUNTRY[iso_country] || iso_country
+    end
+
+    def self.country_is_supported?(iso_country)
+      SUPPORTED_STATES.include?(iso_country)
     end
   end
 end

data/lib/valvat/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Valvat
-  VERSION = "0.9.1"
+  VERSION = '1.1.0'
 end

data/spec/active_model/validations/valvat_validator_spec.rb

@@ -1,28 +1,30 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 if defined?(ActiveModel)
   class Invoice < ModelBase
-    validates :vat_number, :valvat => true
+    validates :vat_number, valvat: true
   end
 
   class InvoiceWithLookup < ModelBase
-    validates :vat_number, :valvat => {:lookup => true}
+    validates :vat_number, valvat: { lookup: true }
   end
 
   class InvoiceWithLookupAndFailIfDown < ModelBase
-    validates :vat_number, :valvat => {:lookup => :fail_if_down}
+    validates :vat_number, valvat: { lookup: :fail_if_down }
   end
 
   class InvoiceAllowBlank < ModelBase
-    validates :vat_number, :valvat => {:allow_blank => true}
+    validates :vat_number, valvat: { allow_blank: true }
   end
 
   class InvoiceAllowBlankOnAll < ModelBase
-    validates :vat_number, :valvat => true, :allow_blank => true
+    validates :vat_number, valvat: true, allow_blank: true
   end
 
   class InvoiceCheckCountry < ModelBase
-    validates :vat_number, :valvat => {:match_country => :country}
+    validates :vat_number, valvat: { match_country: :country }
 
     def country
       @attributes[:country]
@@ -30,7 +32,7 @@ if defined?(ActiveModel)
   end
 
   class InvoiceCheckCountryWithLookup < ModelBase
-    validates :vat_number, :valvat => {:match_country => :country, :lookup => true}
+    validates :vat_number, valvat: { match_country: :country, lookup: true }
 
     def country
       @attributes[:country]
@@ -38,205 +40,235 @@ if defined?(ActiveModel)
   end
 
   class InvoiceWithChecksum < ModelBase
-    validates :vat_number, :valvat => {:checksum => true}
+    validates :vat_number, valvat: { checksum: true }
   end
 
   describe Invoice do
-    context "with valid vat number" do
-      it "should be valid" do
-        expect(Invoice.new(:vat_number => "DE259597697")).to be_valid
+    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) { Invoice.new(:vat_number => "DE259597697123") }
+    context 'with invalid VAT number' do
+      let(:invoice) { described_class.new(vat_number: 'DE259597697123') }
 
-      it "should not be valid" do
+      it 'is not valid' do
         expect(invoice).not_to be_valid
       end
 
-      it "should add default (country specific) error message" do
+      it 'adds default (country specific) error message' do
         invoice.valid?
-        expect(invoice.errors[:vat_number]).to eql(["is not a valid German vat number"])
+        expect(invoice.errors[:vat_number]).to eql(['is not a valid German VAT number'])
       end
 
-      context "with i18n translation in place" do
+      context 'with DE locale' do
         before do
-          I18n.backend.store_translations(:en, :activemodel => {
-            :errors => {:models => {:invoice => {:invalid_vat => "is ugly."}}}
-          })
+          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 "should use translation" do
+        it 'uses translation' do
           invoice.valid?
-          expect(invoice.errors[:vat_number]).to eql(["is ugly."])
+          expect(invoice.errors[:vat_number]).to eql(['is ugly.'])
         end
       end
 
-      context "with i18n translation with country adjective placeholder in place" do
+      context 'with i18n translation with country_adjective placeholder in place' do
         before do
-          I18n.backend.store_translations(:en, :activemodel => {
-            :errors => {:models => {:invoice => {:invalid_vat => "is not a %{country_adjective} vat"}}}
-          })
+          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 "should replace country adjective placeholder" do
-          invoice = Invoice.new(:vat_number => "IE123")
+        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"])
+          expect(invoice.errors[:vat_number]).to eql(['is not a Irish vat'])
         end
 
-        it "should fall back to 'European' if country is missing" do
-          invoice = Invoice.new(:vat_number => "XX123")
+        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"])
+          expect(invoice.errors[:vat_number]).to eql(['is not a European vat'])
         end
       end
     end
 
-    context "with blank vat number" do
-      it "should not be valid" do
-        expect(Invoice.new(:vat_number => "")).not_to be_valid
-        expect(Invoice.new(:vat_number => nil)).not_to be_valid
+    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
+    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)
+        allow(Valvat::Syntax).to receive_messages(validate: true)
+        allow(Valvat::Lookup).to receive_messages(validate: false)
       end
 
-      it "should not be valid" do
-        expect(InvoiceWithLookup.new(:vat_number => "DE123")).not_to be_valid
+      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
+    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)
+        allow(Valvat::Syntax).to receive_messages(validate: true)
+        allow(Valvat::Lookup).to receive_messages(validate: true)
       end
 
-      it "should be valid" do
-        expect(InvoiceWithLookup.new(:vat_number => "DE123")).to be_valid
+      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
+    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)
+        allow(Valvat::Syntax).to receive_messages(validate: true)
+        allow(Valvat::Lookup).to receive_messages(validate: nil)
       end
 
-      it "should be valid" do
-        expect(InvoiceWithLookup.new(:vat_number => "DE123")).to be_valid
+      it 'is valid' do
+        expect(described_class.new(vat_number: 'DE123')).to be_valid
       end
     end
   end
 
   describe InvoiceWithLookupAndFailIfDown do
-    context "with valid vat number and VIES country service down" 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)
+        allow(Valvat::Syntax).to receive_messages(validate: true)
+        allow(Valvat::Lookup).to receive_messages(validate: nil)
       end
 
-      it "should not be valid" do
-        expect(InvoiceWithLookupAndFailIfDown.new(:vat_number => "DE123")).not_to be_valid
+      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 "should be valid" do
-        expect(InvoiceAllowBlank.new(:vat_number => "")).to be_valid
-        expect(InvoiceAllowBlank.new(:vat_number => nil)).to be_valid
+    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 "should be valid" do
-        expect(InvoiceAllowBlankOnAll.new(:vat_number => "")).to be_valid
-        expect(InvoiceAllowBlankOnAll.new(:vat_number => nil)).to be_valid
+    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 "should be not valid on blank country" do
-      expect(InvoiceCheckCountry.new(:country => nil, :vat_number => "DE259597697")).not_to be_valid
-      expect(InvoiceCheckCountry.new(:country => "", :vat_number => "DE259597697")).not_to be_valid
+    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 "should be not valid on wired country" do
-      expect(InvoiceCheckCountry.new(:country => "XAXXX", :vat_number => "DE259597697")).not_to be_valid
-      expect(InvoiceCheckCountry.new(:country => "ZO", :vat_number => "DE259597697")).not_to be_valid
+    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 "should be not valid on mismatching (eu) country" do
-      expect(InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697")).not_to be_valid
-      expect(InvoiceCheckCountry.new(:country => "AT", :vat_number => "DE259597697")).not_to be_valid
-      expect(InvoiceCheckCountry.new(:country => "DE", :vat_number => "ATU65931334")).not_to be_valid
+    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 "should be valid on matching country" do
-      expect(InvoiceCheckCountry.new(:country => "DE", :vat_number => "DE259597697")).to be_valid
-      expect(InvoiceCheckCountry.new(:country => "AT", :vat_number => "ATU65931334")).to be_valid
+    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 "should give back error message with country from :country_match" do
-      invoice = InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697")
+    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"])
+      expect(invoice.errors[:vat_number]).to eql(['is not a valid French VAT number'])
     end
 
-    it "should give back error message with country from :country_match even on invalid vat number" do
-      invoice = InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697123")
+    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"])
+      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)
+      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
-      expect(Valvat::Syntax).not_to receive(:validate)
-      expect(Valvat::Lookup).not_to receive(:validate)
-      InvoiceCheckCountryWithLookup.new(:country => "FR", :vat_number => "DE259597697").valid?
+    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
-      expect(Valvat::Syntax).to receive(:validate).and_return(true)
-      expect(Valvat::Lookup).to receive(:validate).and_return(true)
-      InvoiceCheckCountryWithLookup.new(:country => "DE", :vat_number => "DE259597697").valid?
+    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 "should be valid" do
-        expect(InvoiceWithChecksum.new(:vat_number => "DE259597697")).to be_valid
+    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 "should not be valid" do
-        expect(InvoiceWithChecksum.new(:vat_number => "DE259597687")).not_to be_valid
+    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
+end