valvat 1.1.4 → 1.2.0

data/lib/valvat/lookup/fault.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-class Valvat
-  class Lookup
-    class Fault < Response
-      def to_hash
-        @to_hash ||= case @raw
-        when Savon::HTTPError
-          { error: HTTPError.new(nil, @raw) }
-        when Savon::UnknownOperationError
-          { error: OperationUnknown.new(nil, @raw) }
-        else
-          fault = @raw.to_hash[:fault][:faultstring]
-
-          if fault == 'INVALID_INPUT'
-            { valid: false }
-          else
-            error = (FAULTS[fault] || UnknownViesError).new(fault)
-            { error: error }
-          end
-        end
-      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
-    end
-  end
-end

data/lib/valvat/lookup/request.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'savon'
-
-class Valvat
-  class Lookup
-    class Request
-      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
-        Response.new(
-          client.call(action, message: message, message_tag: message_tag, soap_action: nil)
-        )
-      rescue Savon::SOAPFault, Savon::HTTPError, Savon::UnknownOperationError => e
-        Fault.new(e)
-      end
-
-      private
-
-      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
-        @requester ? :checkVatApprox : :checkVat
-      end
-
-      def action
-        @requester ? :check_vat_approx : :check_vat
-      end
-
-      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

data/lib/valvat/lookup/response.rb

@@ -1,37 +0,0 @@
-# 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/spec/valvat/lookup/fault_spec.rb

@@ -1,34 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-# 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
-
-  context 'when Savon::UnknownOperationError is (wrongly) thrown' do
-    before do
-      dbl = double(Savon::Client)
-      allow(Savon::Client).to receive(:new).and_return(dbl)
-      allow(dbl).to receive(:call).and_raise(Savon::UnknownOperationError.new('from stub'))
-    end
-
-    it "does handle it like vies down" do
-      response = described_class.new('IE6388047V', {}).perform
-      expect(response.to_hash[:error]).to be_a(Valvat::OperationUnknown)
-    end
-  end
-end

data/spec/valvat/lookup/response_spec.rb

@@ -1,29 +0,0 @@
-# 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