valvat 0.5.0 → 0.6.0

data/lib/valvat/locales/pt.yml

@@ -1,34 +1,34 @@
 pt:
   errors:
     messages:
-      invalid_vat: IVA inválido para %{country_adjective}
+      invalid_vat: não é um NIF %{country_adjective} válido.
   valvat:
     country_adjectives:
-      eu: Europa
-      at: Áustria
-      be: Bélgica
-      bg: Bulgária
-      cy: Chipre
-      cz: República Checa
-      de: Alemanha
-      dk: Dinamarca
-      ee: Estónia
-      es: Espanha
-      fi: Finlândia
-      fr: França
-      gb: Reino Unido
-      gr: Grécia
-      hu: Hungria
-      ie: Irlanda
-      it: Itália
-      lt: Lituânia
-      lu: Luxemburgo
-      lv: Letónia
-      mt: Malta
-      nl: Holanda
-      pl: Polónia
-      pt: Portugal
-      ro: Roménia
-      se: Suécia
-      si: Eslovénia
-      sk: Eslováquia
+    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: luxemburguese
+    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

@@ -3,52 +3,79 @@ require 'net/http'
 require 'yaml'
 
 class Valvat
-  module Lookup
+  class Lookup
+    VIES_WSDL_URL = 'http://ec.europa.eu/taxation_customs/vies/checkVatService.wsdl'
+    REMOVE_KEYS = [:valid, :@xmlns]
+
+    attr_reader :vat, :options
 
-    def self.validate(vat, options={})
-      vat = Valvat(vat)
+    def initialize(vat, options={})
+      @vat = Valvat(vat)
+      @options = options || {}
+      @options[:requester_vat] = Valvat(requester_vat) if requester_vat
+    end
+
+    def validate
       return false unless vat.european?
 
-      request = options[:requester_vat] ?
-        Valvat::Lookup::RequestWithId.new(vat, Valvat(options[:requester_vat])) :
-        Valvat::Lookup::Request.new(vat)
-
-      begin
-        response = request.perform(self.client)
-        response[:valid] && (options[:detail] || options[:requester_vat]) ?
-          filter_detail(response) : response[:valid]
-      rescue => err
-        if err.respond_to?(:to_hash) && err.to_hash[:fault] && (err.to_hash[:fault][:faultstring] || "").upcase =~ /INVALID_INPUT/
-          return false
+      valid? && show_details? ? response_details : valid?
+    rescue => error
+      return false if invalid_input?(error)
+      raise error  if options[:raise_error]
+      nil
+    end
+
+    class << self
+      def validate(vat, options={})
+        new(vat, options).validate
+      end
+
+      def client
+        @client ||= begin
+          # Require Savon only if really needed!
+          require 'savon' unless defined?(Savon)
+
+          Savon::Client.new(
+            wsdl: VIES_WSDL_URL,
+            # Quiet down Savon and HTTPI
+            log: false
+          )
         end
-        raise err if options[:raise_error]
-        nil
       end
     end
 
-    def self.client
-      @client ||= begin
-        # Require Savon only if really needed!
-        require 'savon' unless defined?(Savon)
+    private
 
-        # Quiet down HTTPI
-        HTTPI.log = false
+    def valid?
+      response[:valid]
+    end
+
+    def response
+      @response ||= request.perform(self.class.client)
+    end
 
-        Savon::Client.new(
-          wsdl: 'http://ec.europa.eu/taxation_customs/vies/checkVatService.wsdl',
-          namespace: 'urn:ec.europa.eu:taxud:vies:services:checkVat:types',
-          namespaces: {'xmlns:impl'=>'urn:ec.europa.eu:taxud:vies:services:checkVat:types'},
-          # Quiet down Savon
-          log: false
-        )
+    def request
+      if requester_vat
+        RequestWithId.new(vat, requester_vat)
+      else
+        Request.new(vat)
       end
     end
 
-    private
+    def requester_vat
+      options[:requester_vat]
+    end
 
-    REMOVE_KEYS = [:valid, :@xmlns]
+    def invalid_input?(err)
+      return if !err.respond_to?(:to_hash) || !err.to_hash[:fault]
+      (err.to_hash[:fault][:faultstring] || "").upcase =~ /INVALID_INPUT/
+    end
+
+    def show_details?
+      requester_vat || options[:detail]
+    end
 
-    def self.filter_detail(response)
+    def response_details
       response.inject({}) do |hash, kv|
         key, value = kv
         unless REMOVE_KEYS.include?(key)

data/lib/valvat/lookup/request.rb

@@ -1,5 +1,5 @@
 class Valvat
-  module Lookup
+  class Lookup
     class Request
       def initialize(vat)
         @vat = vat

data/lib/valvat/lookup/request_with_id.rb

@@ -1,5 +1,5 @@
 class Valvat
-  module Lookup
+  class Lookup
     class RequestWithId < Request
       def initialize(vat, requester_vat)
         @vat = vat

data/lib/valvat/syntax.rb

@@ -19,7 +19,7 @@ class Valvat
         '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]\Z/,                 # Ireland
+        '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]{9}|[0-9]{12})\Z/,                               # Lithuania
         'LU' => /\ALU[0-9]{8}\Z/,                                           # Luxembourg

data/lib/valvat/version.rb

@@ -1,3 +1,3 @@
 class Valvat
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/spec/active_model/validations/valvat_validator_spec.rb

@@ -0,0 +1,242 @@
+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
+    context "with valid vat number" do
+      it "should be valid" do
+        Invoice.new(:vat_number => "DE259597697").should be_valid
+      end
+    end
+
+    context "with invalid vat number" do
+      let(:invoice) { Invoice.new(:vat_number => "DE259597697123") }
+
+      it "should not be valid" do
+        invoice.should_not be_valid
+      end
+
+      it "should add default (country specific) error message" do
+        invoice.valid?
+        invoice.errors[:vat_number].should 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."}}}
+          })
+        end
+
+        after { I18n.reload! }
+
+        it "should use translation" do
+          invoice.valid?
+          invoice.errors[:vat_number].should eql(["is ugly."])
+        end
+      end
+
+      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"}}}
+          })
+        end
+
+        after { I18n.reload! }
+
+        it "should replace country adjective placeholder" do
+          invoice = Invoice.new(:vat_number => "IE123")
+          invoice.valid?
+          invoice.errors[:vat_number].should 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.valid?
+          invoice.errors[:vat_number].should eql(["is not a European vat"])
+        end
+      end
+    end
+
+    context "with blank vat number" do
+      it "should not be valid" do
+        Invoice.new(:vat_number => "").should_not be_valid
+        Invoice.new(:vat_number => nil).should_not be_valid
+      end
+    end
+  end
+
+  describe InvoiceWithLookup do
+    context "with valid but not existing vat number" do
+      before do
+        Valvat::Syntax.stub(:validate => true)
+        Valvat::Lookup.stub(:validate => false)
+      end
+
+      it "should not be valid" do
+        InvoiceWithLookup.new(:vat_number => "DE123").should_not be_valid
+      end
+    end
+
+    context "with valid and existing vat number" do
+      before do
+        Valvat::Syntax.stub(:validate => true)
+        Valvat::Lookup.stub(:validate => true)
+      end
+
+      it "should be valid" do
+        InvoiceWithLookup.new(:vat_number => "DE123").should be_valid
+      end
+    end
+
+    context "with valid vat number and VIES country service down" do
+      before do
+        Valvat::Syntax.stub(:validate => true)
+        Valvat::Lookup.stub(:validate => nil)
+      end
+
+      it "should be valid" do
+        InvoiceWithLookup.new(:vat_number => "DE123").should be_valid
+      end
+    end
+  end
+
+  describe InvoiceWithLookupAndFailIfDown do
+    context "with valid vat number and VIES country service down" do
+      before do
+        Valvat::Syntax.stub(:validate => true)
+        Valvat::Lookup.stub(:validate => nil)
+      end
+
+      it "should not be valid" do
+        InvoiceWithLookupAndFailIfDown.new(:vat_number => "DE123").should_not be_valid
+      end
+    end
+  end
+
+  describe InvoiceAllowBlank do
+    context "with blank vat number" do
+      it "should be valid" do
+        InvoiceAllowBlank.new(:vat_number => "").should be_valid
+        InvoiceAllowBlank.new(:vat_number => nil).should be_valid
+      end
+    end
+  end
+
+  describe InvoiceAllowBlankOnAll do
+    context "with blank vat number" do
+      it "should be valid" do
+        InvoiceAllowBlankOnAll.new(:vat_number => "").should be_valid
+        InvoiceAllowBlankOnAll.new(:vat_number => nil).should be_valid
+      end
+    end
+  end
+
+  describe InvoiceCheckCountry do
+    it "should be not valid on blank country" do
+      InvoiceCheckCountry.new(:country => nil, :vat_number => "DE259597697").should_not be_valid
+      InvoiceCheckCountry.new(:country => "", :vat_number => "DE259597697").should_not be_valid
+    end
+
+    it "should be not valid on wired country" do
+      InvoiceCheckCountry.new(:country => "XAXXX", :vat_number => "DE259597697").should_not be_valid
+      InvoiceCheckCountry.new(:country => "ZO", :vat_number => "DE259597697").should_not be_valid
+    end
+
+    it "should be not valid on mismatching (eu) country" do
+      InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697").should_not be_valid
+      InvoiceCheckCountry.new(:country => "AT", :vat_number => "DE259597697").should_not be_valid
+      InvoiceCheckCountry.new(:country => "DE", :vat_number => "ATU65931334").should_not be_valid
+    end
+
+    it "should be valid on matching country" do
+      InvoiceCheckCountry.new(:country => "DE", :vat_number => "DE259597697").should be_valid
+      InvoiceCheckCountry.new(:country => "AT", :vat_number => "ATU65931334").should be_valid
+    end
+
+    it "should give back error message with country from :country_match" do
+      invoice = InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697")
+      invoice.valid?
+      invoice.errors[:vat_number].should 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")
+      invoice.valid?
+      invoice.errors[:vat_number].should eql(["is not a valid French vat number"])
+    end
+  end
+
+  describe InvoiceCheckCountryWithLookup do
+    before do
+      Valvat::Syntax.stub(:validate => true)
+      Valvat::Lookup.stub(:validate => true)
+    end
+
+    it "avoids lookup or syntax check on failed because of mismatching country" do
+      Valvat::Syntax.should_not_receive(:validate)
+      Valvat::Lookup.should_not_receive(:validate)
+      InvoiceCheckCountryWithLookup.new(:country => "FR", :vat_number => "DE259597697").valid?
+    end
+
+    it "check syntax and looup on matching country" do
+      Valvat::Syntax.should_receive(:validate).and_return(true)
+      Valvat::Lookup.should_receive(:validate).and_return(true)
+      InvoiceCheckCountryWithLookup.new(:country => "DE", :vat_number => "DE259597697").valid?
+    end
+  end
+
+  describe InvoiceWithChecksum do
+    context "with valid vat number" do
+      it "should be valid" do
+        InvoiceWithChecksum.new(:vat_number => "DE259597697").should be_valid
+      end
+    end
+
+    context "with invalid vat number" do
+      it "should not be valid" do
+        InvoiceWithChecksum.new(:vat_number => "DE259597687").should_not be_valid
+      end
+    end
+  end
+end