valvat 0.9.1 → 1.0.0

data/lib/active_model/validations/valvat_validator.rb

@@ -5,6 +5,20 @@ require 'valvat/lookup'
 module ActiveModel
   module Validations
     class ValvatValidator < EachValidator
+      def initialize(options)
+        if options[:lookup]
+          options[:lookup] = if options[:lookup] == :fail_if_down
+            {fail_if_down: true}
+          elsif options[:lookup].is_a?(Hash)
+            options[:lookup]
+          else
+            {}
+          end
+        end
+
+        super
+      end
+
       def validate_each(record, attribute, value)
         vat = Valvat(value)
         iso_country_code = vat.iso_country_code
@@ -17,10 +31,10 @@ module ActiveModel
 
         iso_country_code = "eu" if iso_country_code.blank?
         record.errors.add(attribute, :invalid_vat,
-          :message => options[:message],
-          :country_adjective => I18n.t(
+          message: options[:message],
+          country_adjective: I18n.t(
             :"valvat.country_adjectives.#{iso_country_code.downcase}",
-            :default => [:"valvat.country_adjectives.eu", "european"]
+            default: [:"valvat.country_adjectives.eu", "european"]
           )
         )
       end
@@ -43,9 +57,10 @@ module ActiveModel
 
       def vat_exists?(vat)
         return true unless options[:lookup]
-        is_valid = vat.exists?
+
+        is_valid = vat.exists?(options[:lookup])
         return is_valid unless is_valid.nil?
-        options[:lookup] != :fail_if_down
+        !options[:lookup][:fail_if_down]
       end
     end
   end

data/lib/valvat.rb

@@ -1,7 +1,9 @@
+require 'valvat/error'
 require 'valvat/local'
 require 'valvat/lookup'
 require 'valvat/lookup/request'
-require 'valvat/lookup/request_with_id'
+require 'valvat/lookup/response'
+require 'valvat/lookup/fault'
 require 'active_model/validations/valvat_validator' if defined?(ActiveModel)
 
 class Valvat

data/lib/valvat/checksum/gb.rb

@@ -3,33 +3,50 @@ class Valvat
     class GB < Base
       OLD_FORMAT_FORBIDDEN_RANGES = [(100_000..999_999), (9_490_001..9_700_000), (9_990_001..9_999_999)]
       NEW_FORMAT_FORBIDDEN_RANGES = [(1..100_000), (100_001..1_000_000)]
+      GOV_NUMBER = /\A(GD[0-4]{1}\d{2})\Z/
+      HEALTH_NUMBER = /\A(HA[5-9]{1}\d{2})\Z/
 
       def validate
         vat_number = vat.to_s_wo_country
-        check_sum  = vat.to_s_wo_country[7..8].to_i
-        vat_base = vat_number[0..6]
 
         # government departments and health authorities, so no checksum
-        return true if vat_number =~ /\A(GD[0-4]{1}\d{2})\Z/ || vat_number =~ /\A(HA[5-9]{1}\d{2})\Z/
-        return false if vat_number =~ /\A0{9}\Z/ || vat_number =~ /\A0{12}\Z/
+        return true if gov_or_health?(vat_number)
+        return false if all_zero?(vat_number)
 
-        vat_base_sum = vat_base.split('').
-          map(&:to_i).
-          zip([8, 7, 6, 5, 4, 3, 2]).
-          map { |vat_number_digit, multiplier| vat_number_digit * multiplier }.
-          inject(:+)
+        checksum  = vat_number[7..8].to_i
+        vat_base = vat_number[0..6]
+        vat_base_int = vat_base.to_i
+        vat_base_sum = generate_vat_base_sum(vat_base)
 
-        old_format_remainder = (vat_base_sum + check_sum).modulo(97)
-        new_format_remainder = (vat_base_sum + 55 + check_sum).modulo(97)
+        old_format_remainder = (vat_base_sum + checksum).modulo(97)
+        new_format_remainder = (vat_base_sum + 55 + checksum).modulo(97)
 
         return false if old_format_remainder == 0 &&
-          OLD_FORMAT_FORBIDDEN_RANGES.any? { |range| range.include? vat_base.to_i }
+          OLD_FORMAT_FORBIDDEN_RANGES.any? { |range| range.include? vat_base_int }
 
         return false if new_format_remainder == 0 &&
-          NEW_FORMAT_FORBIDDEN_RANGES.any? { |range| range.include? vat_base.to_i }
+          NEW_FORMAT_FORBIDDEN_RANGES.any? { |range| range.include? vat_base_int }
 
         old_format_remainder == 0 || new_format_remainder == 0
       end
+
+      private
+
+      def gov_or_health?(vat_number)
+        vat_number =~ GOV_NUMBER || vat_number =~ HEALTH_NUMBER
+      end
+
+      def all_zero?(vat_number)
+        vat_number =~ /\A0{9}\Z/ || vat_number =~ /\A0{12}\Z/
+      end
+
+      def generate_vat_base_sum(vat_base)
+        vat_base.split('').
+          map(&:to_i).
+          zip([8, 7, 6, 5, 4, 3, 2]).
+          map { |vat_number_digit, multiplier| vat_number_digit * multiplier }.
+          inject(:+)
+      end
     end
   end
 end

data/lib/valvat/checksum/ie.rb

@@ -6,7 +6,7 @@ class Valvat
           fig*(i+2)
         end
         if str_wo_country.size == 9
-          total += (CHARS.index(str_wo_country[8]) * 9)
+          total += ((CHARS.index(str_wo_country[8]) || 0)  * 9)
         end
         total.modulo(23)
       end

data/lib/valvat/error.rb

@@ -0,0 +1,28 @@
+class Valvat
+  Error = Class.new(RuntimeError)
+
+  class ViesError < Error
+    def initialize(faultstring='UNKOWN')
+      @faultstring = faultstring
+    end
+
+    def to_s
+      "The VIES web service returned the error '#{@faultstring}'."
+    end
+
+    def eql?(other)
+      to_s.eql?(other.to_s)
+    end
+  end
+  ViesMaintenanceError = Class.new(ViesError)
+
+  ServiceUnavailable = Class.new(ViesMaintenanceError)
+  MemberStateUnavailable = Class.new(ViesMaintenanceError)
+
+  Timeout = Class.new(ViesError)
+  InvalidRequester = Class.new(ViesError)
+  BlockedError = Class.new(ViesError)
+  RateLimitError = Class.new(ViesError)
+
+  UnknownViesError = Class.new(ViesError)
+end

data/lib/valvat/locales/en.yml

@@ -1,7 +1,7 @@
 en:
   errors:
     messages:
-      invalid_vat: is not a valid %{country_adjective} vat number
+      invalid_vat: is not a valid %{country_adjective} VAT number
   valvat:
     country_adjectives:
       eu: European

data/lib/valvat/lookup.rb

@@ -1,36 +1,23 @@
-require 'savon'
-
 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={})
       @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={})
         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 +27,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 ViesMaintenanceError === error
+        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,30 @@
+class Valvat
+  class Lookup
+    class Fault < Response
+      private
+
+      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
+      }
+
+      def self.fault_to_error(fault)
+        (FAULTS[fault] || UnknownViesError).new(fault)
+      end
+    end
+  end
+end

data/lib/valvat/lookup/request.rb

@@ -1,30 +1,51 @@
+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
+        begin
+          Response.new(
+            client.call(action, message: message, message_tag: message_tag)
+          )
+        rescue Savon::SOAPFault => fault
+          Fault.new(fault)
+        end
       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_tag
-        :checkVat
+      def message
+        {
+          country_code: @vat.vat_country_code,
+          vat_number: @vat.to_s_wo_country
+        }.merge(@requester ? {
+            requester_country_code: @requester.vat_country_code,
+            requester_vat_number: @requester.to_s_wo_country
+          } : {}
+        )
       end
 
-      def action
-        :check_vat
+      def message_tag
+        @requester ? :checkVatApprox : :checkVat
       end
 
-      def response_key
-        :check_vat_response
+      def action
+        @requester ? :check_vat_approx : :check_vat
       end
     end
   end

data/lib/valvat/lookup/response.rb

@@ -0,0 +1,36 @@
+class Valvat
+  class Lookup
+    class Response
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def [](key)
+        to_hash[key]
+      end
+
+      def to_hash
+        @hash ||= self.class.cleanup(@raw.to_hash)
+      end
+
+      private
+
+      def self.cleanup(hash)
+        (hash[:check_vat_approx_response] || hash[:check_vat_response] || {}).inject({}) do |hash, (key, value)|
+          hash[cleanup_key(key)] = cleanup_value(value) unless key == :"@xmlns"
+          hash
+        end
+      end
+
+      TRADER_PREFIX = /\Atrader_/
+
+      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/version.rb

@@ -1,3 +1,3 @@
 class Valvat
-  VERSION = "0.9.1"
+  VERSION = "1.0.0"
 end

data/spec/active_model/validations/valvat_validator_spec.rb

@@ -2,27 +2,27 @@ 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 +30,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,18 +38,18 @@ 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
+    context "with valid VAT number" do
       it "should be valid" do
-        expect(Invoice.new(:vat_number => "DE259597697")).to be_valid
+        expect(Invoice.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) { Invoice.new(vat_number: "DE259597697123") }
 
       it "should not be valid" do
         expect(invoice).not_to be_valid
@@ -57,13 +57,13 @@ if defined?(ActiveModel)
 
       it "should add 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
         before do
-          I18n.backend.store_translations(:en, :activemodel => {
-            :errors => {:models => {:invoice => {:invalid_vat => "is ugly."}}}
+          I18n.backend.store_translations(:en, activemodel: {
+            errors: {models: {invoice: {invalid_vat: "is ugly."}}}
           })
         end
 
@@ -77,165 +77,165 @@ if defined?(ActiveModel)
 
       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"}}}
+          I18n.backend.store_translations(:en, activemodel: {
+            errors: {models: {invoice: {invalid_vat: "is not a %{country_adjective} vat"}}}
           })
         end
 
         after { I18n.reload! }
 
         it "should replace country adjective placeholder" do
-          invoice = Invoice.new(:vat_number => "IE123")
+          invoice = Invoice.new(vat_number: "IE123")
           invoice.valid?
           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")
+          invoice = Invoice.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
+    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
+        expect(Invoice.new(vat_number: "")).not_to be_valid
+        expect(Invoice.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
+        expect(InvoiceWithLookup.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
+        expect(InvoiceWithLookup.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
+        expect(InvoiceWithLookup.new(vat_number: "DE123")).to be_valid
       end
     end
   end
 
   describe InvoiceWithLookupAndFailIfDown do
-    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 not be valid" do
-        expect(InvoiceWithLookupAndFailIfDown.new(:vat_number => "DE123")).not_to be_valid
+        expect(InvoiceWithLookupAndFailIfDown.new(vat_number: "DE123")).not_to be_valid
       end
     end
   end
 
   describe InvoiceAllowBlank do
-    context "with blank vat number" 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
+        expect(InvoiceAllowBlank.new(vat_number: "")).to be_valid
+        expect(InvoiceAllowBlank.new(vat_number: nil)).to be_valid
       end
     end
   end
 
   describe InvoiceAllowBlankOnAll do
-    context "with blank vat number" 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
+        expect(InvoiceAllowBlankOnAll.new(vat_number: "")).to be_valid
+        expect(InvoiceAllowBlankOnAll.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
+      expect(InvoiceCheckCountry.new(country: nil, vat_number: "DE259597697")).not_to be_valid
+      expect(InvoiceCheckCountry.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
+      expect(InvoiceCheckCountry.new(country: "XAXXX", vat_number: "DE259597697")).not_to be_valid
+      expect(InvoiceCheckCountry.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
+      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
     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
+      expect(InvoiceCheckCountry.new(country: "DE", vat_number: "DE259597697")).to be_valid
+      expect(InvoiceCheckCountry.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")
+      invoice = InvoiceCheckCountry.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 "should give back error message with country from :country_match even on invalid VAT number" do
+      invoice = InvoiceCheckCountry.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?
+      InvoiceCheckCountryWithLookup.new(country: "FR", vat_number: "DE259597697").valid?
     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?
+      InvoiceCheckCountryWithLookup.new(country: "DE", vat_number: "DE259597697").valid?
     end
   end
 
   describe InvoiceWithChecksum do
-    context "with valid vat number" do
+    context "with valid VAT number" do
       it "should be valid" do
-        expect(InvoiceWithChecksum.new(:vat_number => "DE259597697")).to be_valid
+        expect(InvoiceWithChecksum.new(vat_number: "DE259597697")).to be_valid
       end
     end
 
-    context "with invalid vat number" do
+    context "with invalid VAT number" do
       it "should not be valid" do
-        expect(InvoiceWithChecksum.new(:vat_number => "DE259597687")).not_to be_valid
+        expect(InvoiceWithChecksum.new(vat_number: "DE259597687")).not_to be_valid
       end
     end
   end