valvat 0.9.1 → 1.1.1

data/spec/valvat/checksum/lu_spec.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::LU do
-  %w(LU13669580 LU25361352 LU23124018 LU17560609).each do |valid_vat|
-    it "returns true on valid vat #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
+  %w[LU13669580 LU25361352 LU23124018 LU17560609].each do |valid_vat|
+    it "returns true on valid VAT #{valid_vat}" do
+      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-2]}#{valid_vat[-3]}#{valid_vat[-1]}"
 
-    it "returns false on invalid vat #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
+    it "returns false on invalid VAT #{invalid_vat}" do
+      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
     end
   end
-end
+end

data/spec/valvat/checksum/mt_spec.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::MT do
-  %w(MT11407334 MT10126313 MT11539237).each do |valid_vat|
-    it "returns true on valid vat #{valid_vat}" do
+  %w[MT11407334 MT10126313 MT11539237].each do |valid_vat|
+    it "returns true on valid VAT #{valid_vat}" do
       expect(Valvat::Checksum.validate(valid_vat)).to be true
     end
 
     invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
 
-    it "returns false on invalid vat #{invalid_vat}" do
+    it "returns false on invalid VAT #{invalid_vat}" do
       expect(Valvat::Checksum.validate(invalid_vat)).to be false
     end
   end

data/spec/valvat/checksum/nl_spec.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::NL do
-  %w(NL123456782B12 NL802549391B01 NL808661863B01 NL820893559B01 NL000099998B57 NL123456789B13).each do |valid_vat|
-    it "returns true on valid vat #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
+  %w[NL123456782B12 NL802549391B01 NL808661863B01 NL820893559B01 NL000099998B57 NL123456789B13].each do |valid|
+    it "returns true on valid VAT #{valid}" do
+      expect(Valvat::Checksum.validate(valid)).to be(true)
     end
 
-    invalid_vat = "#{valid_vat[0..-5]}#{valid_vat[-2]}#{valid_vat[-3]}#{valid_vat[-4]}#{valid_vat[-1]}#{valid_vat[-2]}#{valid_vat[-3]}"
+    invalid = "#{valid[0..-5]}#{valid[-2]}#{valid[-3]}#{valid[-4]}#{valid[-1]}#{valid[-2]}#{valid[-3]}"
 
-    it "returns false on invalid vat #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
+    it "returns false on invalid VAT #{invalid}" do
+      expect(Valvat::Checksum.validate(invalid)).to be(false)
     end
   end
-end
+end

data/spec/valvat/checksum/pl_spec.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::PL do
-  %w(PL8567346215 PL5260211587 PL9720575348 PL5272650022).each do |valid_vat|
-    it "returns true on valid vat #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
+  %w[PL8567346215 PL5260211587 PL9720575348 PL5272650022].each do |valid_vat|
+    it "returns true on valid VAT #{valid_vat}" do
+      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-1]}#{valid_vat[-2]}#{valid_vat[-3]}"
 
-    it "returns false on invalid vat #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
+    it "returns false on invalid VAT #{invalid_vat}" do
+      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
     end
   end
 
-  it "returns false on special case invalid vat PL8566445330" do
-    expect(Valvat::Checksum.validate("PL8566445330")).to eql(false)
+  it 'returns false on special case invalid VAT PL8566445330' do
+    expect(Valvat::Checksum.validate('PL8566445330')).to be(false)
   end
-end
+end

data/spec/valvat/checksum/pt_spec.rb

@@ -1,31 +1,30 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::PT do
-
-  subject { Valvat::Checksum }
-
-  %w(PT136695973 PT501413197 PT503037753 PT500243590 PT500100144 PT502921838).each do |valid_vat|
-    it "returns true on valid vat #{valid_vat}" do
-      expect(subject.validate(valid_vat)).to eql(true)
+  %w[PT136695973 PT501413197 PT503037753 PT500243590 PT500100144 PT502921838].each do |valid_vat|
+    it "returns true on valid VAT #{valid_vat}" do
+      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
     end
 
     invalid_vat = "#{valid_vat[0..-5]}#{valid_vat[-1]}#{valid_vat[-4]}#{valid_vat[-2]}#{valid_vat[-3]}"
 
-    it "returns false on invalid vat #{invalid_vat}" do
-      expect(subject.validate(invalid_vat)).to eql(false)
+    it "returns false on invalid VAT #{invalid_vat}" do
+      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
     end
   end
 
   # Portuguese business VAT should start with the following numbers
   # 1 or 2 (pessoa singular)                             - singular person
   # 5 (pessoa colectiva)                                 - collective person
-  # 6 (pessoa colectiva pública)                         - public collective person
-  # 8 (empresário em nome individual)                    - individual enterpreneur
-  # 9 (pessoa colectiva irregular ou número provisório)  - provisional number
+  # 6 (pessoa colectiva publica)                         - public collective person
+  # 8 (empresario em nome individual)                    - individual enterpreneur
+  # 9 (pessoa colectiva irregular ou numero provisorio)  - provisional number
   # http://www.nif.pt/nif-das-empresas/
-  %w(PT148166644 PT111623448 PT204874866 PT292261314 PT579104222 PT628910002 PT812627318 PT943935784).each do |number|
+  %w[PT148166644 PT111623448 PT204874866 PT292261314 PT579104222 PT628910002 PT812627318 PT943935784].each do |number|
     it "returns true on a valid number - #{number}" do
-      expect(subject.validate(number)).to eql(true)
+      expect(Valvat::Checksum.validate(number)).to be(true)
     end
   end
 end

data/spec/valvat/checksum/ro_spec.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::RO do
-  %w(RO123456789 RO99908 RO19 RO124 RO13182060).each do |valid_vat|
-    it "returns true on valid vat #{valid_vat}" do
+  %w[RO123456789 RO99908 RO19 RO124 RO13182060].each do |valid_vat|
+    it "returns true on valid VAT #{valid_vat}" do
       expect(Valvat::Checksum.validate(valid_vat)).to be true
     end
 
     invalid_vat = "#{valid_vat[0..-3]}#{valid_vat[-1]}#{valid_vat[-2]}"
 
-    it "returns false on invalid vat #{invalid_vat}" do
+    it "returns false on invalid VAT #{invalid_vat}" do
       expect(Valvat::Checksum.validate(invalid_vat)).to be false
     end
   end

data/spec/valvat/checksum/se_spec.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::SE do
-  %w(SE136695975501 SE556464687401 SE502052817901 SE556555952201 SE556084097601).each do |valid_vat|
-    it "returns true on valid vat #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
+  %w[SE136695975501 SE556464687401 SE502052817901 SE556555952201 SE556084097601].each do |valid_vat|
+    it "returns true on valid VAT #{valid_vat}" do
+      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
     end
 
     invalid_vat = "#{valid_vat[0..-4]}#{valid_vat[-1]}#{valid_vat[-2]}#{valid_vat[-3]}"
 
-    it "returns false on invalid vat #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
+    it "returns false on invalid VAT #{invalid_vat}" do
+      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
     end
   end
 
-  it "returns false on special case invalid vat SE556464687400" do
-    expect(Valvat::Checksum.validate("SE556464687400")).to eql(false)
+  it 'returns false on special case invalid VAT SE556464687400' do
+    expect(Valvat::Checksum.validate('SE556464687400')).to be(false)
   end
-end
+end

data/spec/valvat/checksum/si_spec.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::SI do
-  %w(SI59082437 SI51049406 SI86154575 SI47431857 SI22511822 SI26833921).each do |valid_vat|
-    it "returns true on valid vat #{valid_vat}" do
-      expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
+  %w[SI59082437 SI51049406 SI86154575 SI47431857 SI22511822 SI26833921].each do |valid_vat|
+    it "returns true on valid VAT #{valid_vat}" do
+      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
     end
 
-    invalid_vat = "#{valid_vat[0..-2]}#{valid_vat[-1].to_i+1}"
+    invalid_vat = "#{valid_vat[0..-2]}#{valid_vat[-1].to_i + 1}"
 
-    it "returns false on invalid vat #{invalid_vat}" do
-      expect(Valvat::Checksum.validate(invalid_vat)).to eql(false)
+    it "returns false on invalid VAT #{invalid_vat}" do
+      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
     end
   end
 
-  it "returns false on special case invalid vat SI11111107" do
-    expect(Valvat::Checksum.validate("SI11111107")).to eql(false)
+  it 'returns false on special case invalid VAT SI11111107' do
+    expect(Valvat::Checksum.validate('SI11111107')).to be(false)
   end
 
-  it "returns false on special case invalid vat SI01111108" do
-    expect(Valvat::Checksum.validate("SI01111108")).to eql(false)
+  it 'returns false on special case invalid VAT SI01111108' do
+    expect(Valvat::Checksum.validate('SI01111108')).to be(false)
   end
 end

data/spec/valvat/checksum_spec.rb

@@ -1,25 +1,40 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 begin
-  require File.dirname(__FILE__) + '/../../tmp/valid_vat_numbers.rb'
+  require "#{File.dirname(__FILE__)}/../../tmp/valid_vat_numbers.rb"
 rescue LoadError
-  VALID_VAT_NUMBERS = []
+  VALID_VAT_NUMBERS = [].freeze
 end
 
+# Syntax is correct, but checksum invalid
+INVALID_VAT_NUMBERS = %w[
+  DE002768611 DE161216774 DE192970834 DE223361232 DE226095231
+  DE227411313 DE230928917 DE232123248 DE267748405 DE275615509
+  DE311927825 DE329214395 DE815842425 DE821530465 DE999999999
+].freeze
+
 describe Valvat::Checksum do
-  describe "#validate" do
-    it "returns true on vat number with unknown checksum algorithm" do
-      expect(Valvat::Checksum.validate("CZ699001237")).to eql(true)
+  describe '#validate' do
+    it 'returns true on VAT number with unknown checksum algorithm' do
+      expect(described_class.validate('CZ699001237')).to be(true)
     end
 
-    it "returns false on corrupt number (e.g checks syntax)" do
-      expect(Valvat::Checksum.validate("FI1234567891")).to eql(false)
+    it 'returns false on corrupt number (e.g checks syntax)' do
+      expect(described_class.validate('FI1234567891')).to be(false)
     end
 
     VALID_VAT_NUMBERS.each do |valid_vat|
-      it "returns true on valid vat number #{valid_vat}" do
-        expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
+      it "returns true on valid VAT number #{valid_vat}" do
+        expect(described_class.validate(valid_vat)).to be(true)
+      end
+    end
+
+    INVALID_VAT_NUMBERS.each do |invalid_vat|
+      it "returns false on invalid VAT number #{invalid_vat}" do
+        expect(described_class.validate(invalid_vat)).to be(false)
       end
     end
   end
-end
+end

data/spec/valvat/lookup/fault_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Valvat::Lookup::Fault do
+  it "returns {valid: false} on fault 'INVALID_INPUT'" do
+    expect(described_class.new({
+                                 fault: { faultstring: 'INVALID_INPUT' }
+                               }).to_hash).to eql({ valid: false })
+  end
+
+  {
+    'SERVICE_UNAVAILABLE' => Valvat::ServiceUnavailable,
+    'MS_UNAVAILABLE' => Valvat::MemberStateUnavailable,
+    'INVALID_REQUESTER_INFO' => Valvat::InvalidRequester,
+    'TIMEOUT' => Valvat::Timeout,
+    'VAT_BLOCKED' => Valvat::BlockedError,
+    'IP_BLOCKED' => Valvat::BlockedError,
+    'GLOBAL_MAX_CONCURRENT_REQ' => Valvat::RateLimitError,
+    'GLOBAL_MAX_CONCURRENT_REQ_TIME' => Valvat::RateLimitError,
+    'MS_MAX_CONCURRENT_REQ' => Valvat::RateLimitError,
+    'MS_MAX_CONCURRENT_REQ_TIME' => Valvat::RateLimitError,
+    'ANYTHING ELSE' => Valvat::UnknownViesError,
+    'REALLY ANYTHING' => Valvat::UnknownViesError
+  }.each do |fault, error|
+    it "returns error on fault '#{fault}'" do
+      expect(described_class.new({
+                                   fault: { faultstring: fault }
+                                 }).to_hash).to eql({
+                                                      error: error.new(fault)
+                                                    })
+    end
+  end
+end

data/spec/valvat/lookup/request_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Valvat::Lookup::Request do
+  it 'returns Response on success' do
+    response = described_class.new('IE6388047V', {}).perform
+    expect(response).to be_a(Valvat::Lookup::Response)
+
+    # Skip if VIES is down
+    expect(response.to_hash[:name]).to eql('GOOGLE IRELAND LIMITED') unless response.is_a?(Valvat::Lookup::Fault)
+  end
+
+  it 'returns Fault on failure' do
+    response = described_class.new('XC123123', {}).perform
+    expect(response).to be_a(Valvat::Lookup::Fault)
+    expect(response.to_hash).to eql({ valid: false })
+  end
+end

data/spec/valvat/lookup/response_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Valvat::Lookup::Response do
+  it 'removes @xmlns from :check_vat_response hash' do
+    expect(described_class.new({
+                                 check_vat_response: { :a => 1, :b => 2, :@xmlns => true }
+                               }).to_hash).to eql({ a: 1, b: 2 })
+  end
+
+  it "removes 'trader_'-Prefixes :check_vat_response hash" do
+    expect(described_class.new({
+                                 check_vat_response: { a: 1, trader_b: 2 }
+                               }).to_hash).to eql({ a: 1, b: 2 })
+  end
+
+  it 'accepts hash keyed as :check_vat_approx_response' do
+    expect(described_class.new({
+                                 check_vat_approx_response: { a: 1, b: 2 }
+                               }).to_hash).to eql({ a: 1, b: 2 })
+  end
+
+  it 'allows direct access to hash via []' do
+    expect(described_class.new({
+                                 check_vat_response: { a: 123, b: 2 }
+                               })[:a]).to be(123)
+  end
+end

data/spec/valvat/lookup_spec.rb

@@ -1,125 +1,243 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Lookup do
-  describe "#validate" do
-    context "existing vat number" do
+  describe '#validate' do
+    context 'with existing VAT number' do
+      it 'returns true' do
+        result = described_class.validate('IE6388047V')
+        # Skip if VIES is down
+        expect(result).to be(true) unless result.nil?
+      end
 
-      it "returns true" do
-        result = Valvat::Lookup.validate("IE6388047V")
+      it 'allows Valvat instance as input' do
+        result = described_class.validate(Valvat.new('IE6388047V'))
+        # Skip if VIES is down
+        expect(result).to be(true) unless result.nil?
+      end
+    end
 
-        unless result.nil?
-          expect(result).to eql(true)
-        else
-          puts "Skipping IE vies lookup spec"
-        end
+    context 'with not existing VAT number' do
+      it 'returns false' do
+        result =  described_class.validate('IE6388048V')
+        # Skip if VIES is down
+        expect(result).to be(false) unless result.nil?
       end
+    end
 
-      it "allows Valvat instance as input" do
-        result = Valvat::Lookup.validate(Valvat.new("IE6388047V"))
+    context 'with invalid country code / input' do
+      it 'returns false' do
+        expect(described_class.validate('AE259597697')).to be(false)
+        expect(described_class.validate('')).to be(false)
+      end
+    end
+
+    context 'with details' do
+      let(:details) do
+        {
+          country_code: 'IE',
+          vat_number: '6388047V',
+          name: 'GOOGLE IRELAND LIMITED',
+          address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
+          valid: true
+        }
+      end
 
-        unless result.nil?
-          expect(result).to eql(true)
-        else
-          puts "Skipping IE vies lookup spec"
+      it 'returns hash of details instead of true' do
+        result = described_class.validate('IE6388047V', detail: true)
+        # Skip if VIES is down
+        if result
+          expect(result.delete(:request_date)).to be_kind_of(Date)
+          expect(result).to eql(details)
         end
       end
+
+      it 'still returns false on not existing VAT number' do
+        result = described_class.validate('LU21416128', detail: true)
+        # Skip if VIES is down
+        expect(result).to be(false) unless result.nil?
+      end
     end
 
-    context "not existing vat number" do
-      it "returns false" do
-        result =  Valvat::Lookup.validate("IE6388048V")
+    context 'with request identifier' do
+      let(:response) { described_class.validate('IE6388047V', requester: 'IE6388047V') }
+      let(:details) do
+        {
+          country_code: 'IE',
+          vat_number: '6388047V',
+          name: 'GOOGLE IRELAND LIMITED',
+          company_type: nil,
+          address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
+          valid: true
+        }
+      end
 
-        unless result.nil?
-          expect(result).to eql(false)
-        else
-          puts "Skipping IE vies lookup spec"
+      it 'returns hash of details instead of true' do
+        # Skip if VIES is down
+        if response
+          expect(response.delete(:request_identifier).size).to be(16)
+          expect(response.delete(:request_date)).to be_kind_of(Date)
+          expect(response).to eql(details)
         end
       end
+
+      it 'supports old :requester_vat option for backwards stability' do
+        expect(
+          described_class.new('IE6388047V', requester_vat: 'LU21416127').instance_variable_get(:@options)[:requester]
+        ).to eql('LU21416127')
+      end
     end
+  end
 
-    context "invalid country code / input" do
-      it "returns false" do
-        expect(Valvat::Lookup.validate("AE259597697")).to eql(false)
-        expect(Valvat::Lookup.validate("")).to eql(false)
+  describe '#validate with VIES test enviroment' do
+    let(:options) do
+      { savon: { wsdl: 'https://ec.europa.eu/taxation_customs/vies/checkVatTestService.wsdl' },
+        skip_local_validation: true }
+    end
+
+    context 'with valid request with valid VAT number' do
+      subject(:result) { described_class.validate('DE100', options) }
+
+      it 'returns true' do
+        expect(result).to be(true)
       end
     end
 
-    context "with details" do
-      it "returns hash of details instead of true" do
-        result = Valvat::Lookup.validate("IE6388047V", :detail => true)
+    context 'with valid request with an invalid VAT number' do
+      subject(:result) { described_class.validate('DE200', options) }
 
-         if result
-          expect(result.delete(:request_date)).to be_kind_of(Date)
-          expect(result).to eql({
-            :country_code=>"IE",
-            :vat_number=>"6388047V",
-            :name=>"GOOGLE IRELAND LIMITED",
-            :address=>"3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4"
-          })
-        else
-          puts "Skipping IE vies lookup spec; result = #{result.inspect}"
-        end
+      it 'returns false' do
+        expect(result).to be(false)
       end
+    end
 
-      it "still returns false on not existing vat number" do
-        result =  Valvat::Lookup.validate("LU21416128", :detail => true)
+    describe 'Error : INVALID_INPUT' do
+      subject(:result) { described_class.validate('DE201', options) }
 
-        unless result.nil?
-          expect(result).to eql(false)
-        else
-          puts "Skipping LU vies lookup spec"
-        end
+      it 'returns false' do
+        expect(result).to be(false)
       end
     end
 
-    context "with request identifier" do
-      it "returns hash of details instead of true" do
-        response = Valvat::Lookup.validate("IE6388047V", :requester_vat => "IE6388047V")
+    describe 'Error : INVALID_REQUESTER_INFO' do
+      subject(:result) { described_class.validate('DE202', options) }
 
-        if response
-          expect(response[:request_identifier].size).to eql(16)
-          request_identifier = response[:request_identifier]
-          expect(response.delete(:request_date)).to be_kind_of(Date)
-          expect(response).to eql({
-            :country_code=>"IE",
-            :vat_number=>"6388047V",
-            :name => "GOOGLE IRELAND LIMITED",
-            :company_type=>nil,
-            :address => "3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4",
-            :request_identifier=> request_identifier
-          })
-        else
-          puts "Skipping IE vies lookup spec"
-        end
+      it 'raises Valvat::InvalidRequester' do
+        expect { result }.to raise_error(Valvat::InvalidRequester)
+      end
+    end
+
+    describe 'Error : SERVICE_UNAVAILABLE' do
+      subject(:result) { described_class.validate('DE300', options) }
+
+      it 'returns nil' do
+        expect(result).to be(nil)
+      end
+
+      it 'raises error with raise_error: true' do
+        expect do
+          described_class.validate('DE300', options.merge(raise_error: true))
+        end.to raise_error(Valvat::ServiceUnavailable)
+      end
+    end
+
+    describe 'Error : MS_UNAVAILABLE' do
+      subject(:result) { described_class.validate('DE301', options) }
+
+      it 'returns nil' do
+        expect(result).to be(nil)
+      end
+
+      it 'raises error with raise_error: true' do
+        expect do
+          described_class.validate('DE301', options.merge(raise_error: true))
+        end.to raise_error(Valvat::MemberStateUnavailable)
       end
     end
 
-    context "error on request" do
-      before do
-        @request = double("request")
-        allow(Valvat::Lookup::Request).to receive_messages(:new => @request)
-        allow(@request).to receive(:perform).and_raise(ArgumentError.new)
+    describe 'Error : TIMEOUT' do
+      subject(:result) { described_class.validate('DE302', options) }
+
+      it 'raises error' do
+        expect { result }.to raise_error(Valvat::Timeout)
       end
 
-      it "should return nil" do
-        expect(Valvat::Lookup.validate("LU21416127")).to eql(nil)
+      it 'returns nil with raise_error set to false' do
+        expect(described_class.validate('DE302', options.merge(raise_error: false))).to be(nil)
       end
+    end
+
+    describe 'Error : VAT_BLOCKED' do
+      subject(:result) { described_class.validate('DE400', options) }
 
-      it "should raise error with raise_error option" do
-        expect {Valvat::Lookup.validate("LU21416127", :raise_error => true)}.to raise_error(ArgumentError)
+      it 'raises error' do
+        expect { result }.to raise_error(Valvat::BlockedError, /VAT_BLOCKED/)
+      end
+
+      it 'returns nil with raise_error set to false' do
+        expect(described_class.validate('DE400', options.merge(raise_error: false))).to be(nil)
       end
     end
 
-    # TODO : Reactivate with coorect "down" response
-    # context "country web service down" do
-    #   before do
-    #     json = "{\"error_message\": \"Member State service unavailable.\", \"error_code\": 1, \"error\": true}"
-    #     FakeWeb.register_uri(:get, "http://isvat.appspot.com/DE/259597697/", :body => json)
-    #   end
+    describe 'Error : IP_BLOCKED' do
+      subject(:result) { described_class.validate('DE401', options) }
 
-    #   it "returns nil" do
-    #     Valvat::Lookup.validate("DE259597697").should eql(nil)
-    #   end
-    # end
+      it 'raises error' do
+        expect { result }.to raise_error(Valvat::BlockedError, /IP_BLOCKED/)
+      end
+
+      it 'returns nil with raise_error set to false' do
+        expect(described_class.validate('DE401', options.merge(raise_error: false))).to be(nil)
+      end
+    end
+
+    describe 'Error : GLOBAL_MAX_CONCURRENT_REQ' do
+      subject(:result) { described_class.validate('DE500', options) }
+
+      it 'raises error' do
+        expect { result }.to raise_error(Valvat::RateLimitError, /GLOBAL_MAX_CONCURRENT_REQ/)
+      end
+
+      it 'returns nil with raise_error set to false' do
+        expect(described_class.validate('DE500', options.merge(raise_error: false))).to be(nil)
+      end
+    end
+
+    describe 'Error : GLOBAL_MAX_CONCURRENT_REQ_TIME' do
+      subject(:result) { described_class.validate('DE501', options) }
+
+      it 'raises error' do
+        expect { result }.to raise_error(Valvat::RateLimitError, /GLOBAL_MAX_CONCURRENT_REQ_TIME/)
+      end
+
+      it 'returns nil with raise_error set to false' do
+        expect(described_class.validate('DE501', options.merge(raise_error: false))).to be(nil)
+      end
+    end
+
+    describe 'Error : MS_MAX_CONCURRENT_REQ' do
+      subject(:result) { described_class.validate('DE600', options) }
+
+      it 'raises error' do
+        expect { result }.to raise_error(Valvat::RateLimitError, /MS_MAX_CONCURRENT_REQ/)
+      end
+
+      it 'returns nil with raise_error set to false' do
+        expect(described_class.validate('DE600', options.merge(raise_error: false))).to be(nil)
+      end
+    end
+
+    describe 'Error : MS_MAX_CONCURRENT_REQ_TIME' do
+      subject(:result) { described_class.validate('DE601', options) }
+
+      it 'raises error' do
+        expect { result }.to raise_error(Valvat::RateLimitError, /MS_MAX_CONCURRENT_REQ_TIME/)
+      end
+
+      it 'returns nil with raise_error set to false' do
+        expect(described_class.validate('DE601', options.merge(raise_error: false))).to be(nil)
+      end
+    end
   end
 end