europe 0.0.26 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f6e189312895736dcfbb848edb51298272702f0a051133ce1fa10ff0ca332e9
-  data.tar.gz: 772a816ac59d52a91428f94f998be5f42624a02c25698afea20c27789cb48071
+  metadata.gz: 988b8443805f27f2cb40846b2a2cef3cee76ac464f5c134f833c0ba63acdfce7
+  data.tar.gz: '087c687254747b8d653dad7f33de58f52474acfe5211b8a17a1e3be8d3d12fcb'
 SHA512:
-  metadata.gz: 0d5827fce7a70c52def8b0869bca24fa7688363925ebc3e5c74f52f2f15a7b1d51277515f8a95418cb31ea1efdfc9b3357f5d00c7580a5a54a6920e22d83c815
-  data.tar.gz: 7a5f8f4f1a5dac64cf8c449ab06a20751c73c8b86a0aa7b7eecc2f452b797435de303016886bc87bac6a8add7b5917e08da6441ded34a859ac90f6e897117d31
+  metadata.gz: 70a9e075c5b0c73d8472eb32729c6641a8a365a728be765f5b567516fface3113a2d6fd7751408af1c4aab67e6455a2b138bb92e99fbec41436ce4ae7fd5eb06
+  data.tar.gz: b03c256f4cb9e82129fd549dd57d38681df03877df510b6f224c25f9ddfa2125a44cb1279868d58f487d45971100461cf74722527437552d2db941e0921fc839

data/.rubocop.yml

@@ -16,3 +16,18 @@ Style/RedundantRegexpCharacterClass:
 
 Style/CaseLikeIf:
   Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Max: 150
+  CountAsOne: ['hash', 'array']
+
+Metrics/ClassLength:
+  Exclude:
+    - 'test/**/*'
+
+Metrics/MethodLength:
+  Exclude:
+    - 'test/**/*'

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
+## 0.0.28
+  - Added support for batch VAT checks
+  - Updated fallback rates for Estonia and Romania
+  - [Full Changelog](https://github.com/gem-shards/europe.rb/compare/v0.0.27...v0.0.28)
+## 0.0.27
+  - Updated VIES VAT check service to their REST API instead of their SOAP API
+  - Improved error handling for the VAT check service
+  - Changed the endpoint to check for VAT rates to increase it's stability
+  - [Full Changelog](https://github.com/gem-shards/europe.rb/compare/v0.0.26...v0.0.27)
 ## 0.0.26
   - Removed spaces by default for VAT number format validations, as per request from tim-vandecasteele
   - [Full Changelog](https://github.com/gem-shards/europe.rb/compare/v0.0.25...v0.0.26)

data/README.md

@@ -7,6 +7,7 @@ This gem provides EU governmental data, extracted from various EU / EC websites.
 - [Installation](#installation)
 - [Usage](#usage)
   - [Validating VAT numbers](#validating-vat-numbers)
+  - [Batch VAT validation](#batch-vat-validation)
   - [Validate VAT number format](#validate-vat-number-format)
   - [Validate Postal code format](#validate-postal-code-format)
   - [Retrieving VAT rates for each EC/EU member](#retrieving-vat-rates-for-each-eceu-member)
@@ -55,6 +56,34 @@ Response
   :address => nil }
 ```
 
+### Batch VAT validation
+Validate 3-100 VAT numbers in one request using the VIES batch API. The process is asynchronous: submit numbers, poll for status, then download the report.
+
+**Step 1: Submit batch**
+```ruby
+result = Europe::Vat::Batch.validate(['NL009291477B01', 'BE0123456789', 'DE123456789'])
+# => { token: "a1b2c3d4-..." }
+```
+Optionally pass your own VAT number as requester:
+```ruby
+result = Europe::Vat::Batch.validate(vat_numbers, requester: 'NL009291477B01')
+```
+
+**Step 2: Check status**
+```ruby
+Europe::Vat::Batch.status(result[:token])
+# => { token: "a1b2c3d4-...", filename: "batch.csv", status: :completed,
+#      percentage: 100, created_at: "2026-06-08...", completed_at: "2026-06-08..." }
+```
+
+**Step 3: Download report**
+```ruby
+report = Europe::Vat::Batch.result(result[:token])
+# => { data: "...csv content...", content_type: "text/csv", filename: "report.csv" }
+```
+
+All methods return error symbols on failure (`:timeout`, `:service_unavailable`, `:too_few_rows`, `:too_many_rows`, etc.).
+
 ### Validate VAT number format
 Call
 ```ruby

data/lib/europe/vat/batch.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+require 'securerandom'
+
+module Europe
+  module Vat
+    # Batch VAT validation via VIES REST API
+    module Batch
+      BATCH_API_URL = 'https://ec.europa.eu/taxation_customs/vies/rest-api/vat-validation'
+      BATCH_REPORT_URL = 'https://ec.europa.eu/taxation_customs/vies/rest-api/vat-validation-report'
+
+      BATCH_ERRORS = {
+        'VOW-ERR-6000' => :invalid_file_extension,
+        'VOW-ERR-6001' => :too_many_rows,
+        'VOW-ERR-6002' => :too_few_rows,
+        'VOW-ERR-6005' => :filter_violation,
+        'VOW-ERR-6006' => :token_not_found,
+        'VOW-ERR-6007' => :invalid_file_structure,
+        'VOW-ERR-6008' => :invalid_file_structure,
+        'VOW-ERR-6011' => :file_too_large
+      }.freeze
+
+      BATCH_MIN_ROWS = 3
+      BATCH_MAX_ROWS = 100
+
+      HEADERS = {
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/json'
+      }.freeze
+
+      class << self
+        def validate(vat_numbers, requester: nil)
+          return :too_few_rows if vat_numbers.size < BATCH_MIN_ROWS
+          return :too_many_rows if vat_numbers.size > BATCH_MAX_ROWS
+
+          with_error_handling do
+            body = parse_json_response(upload(generate_csv(vat_numbers, requester)))
+            return body if body.is_a?(Symbol)
+
+            { token: body['token'] }
+          end
+        end
+
+        def status(token)
+          with_error_handling do
+            body = parse_json_response(http_get("#{BATCH_API_URL}/#{token}", HEADERS))
+            return body if body.is_a?(Symbol)
+
+            {
+              token: body['token'], filename: body['filename'],
+              status: body['status']&.downcase&.to_sym, percentage: body['percentage'],
+              created_at: body['creationDateTime'], completed_at: body['completionTime']
+            }
+          end
+        end
+
+        def result(token)
+          with_error_handling do
+            response = http_get("#{BATCH_REPORT_URL}/#{token}")
+            return handle_error(response) unless response.is_a?(Net::HTTPSuccess)
+
+            error = check_json_error(response)
+            return error if error
+
+            { data: response.body, content_type: response['Content-Type'], filename: extract_filename(response) }
+          end
+        end
+
+        private
+
+        def with_error_handling
+          yield
+        rescue Net::OpenTimeout, Net::ReadTimeout
+          :timeout
+        rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, SocketError, OpenSSL::SSL::SSLError
+          :service_unavailable
+        rescue JSON::ParserError
+          :service_error
+        end
+
+        def http_get(url, headers = {})
+          uri = URI.parse(url)
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+            http.request(Net::HTTP::Get.new(uri.request_uri, headers))
+          end
+        end
+
+        def parse_json_response(response)
+          return handle_error(response) unless response.is_a?(Net::HTTPSuccess)
+
+          body = JSON.parse(response.body)
+          return handle_error_body(body) if body['actionSucceed'] == false
+
+          body
+        end
+
+        def check_json_error(response)
+          return unless response['Content-Type']&.include?('application/json')
+
+          body = JSON.parse(response.body)
+          handle_error_body(body) if body['actionSucceed'] == false
+        end
+
+        def extract_filename(response)
+          disposition = response['Content-Disposition']
+          return unless disposition
+
+          disposition.match(/filename="?(.+?)"?(?:;|$)/)&.captures&.first
+        end
+
+        def handle_error(response)
+          body = JSON.parse(response.body)
+          handle_error_body(body)
+        rescue JSON::ParserError
+          :service_error
+        end
+
+        def handle_error_body(body)
+          error_code = body.dig('errorWrappers', 0, 'error')
+          BATCH_ERRORS[error_code] || Vat::VIES_ERRORS[error_code] || :service_error
+        end
+
+        def generate_csv(vat_numbers, requester)
+          requester_cc = requester ? requester[0..1] : ''
+          requester_vat = requester ? requester[2..-1] : ''
+          rows = ['"MS Code","VAT Number","Requester MS Code","Requester VAT Number"']
+          vat_numbers.each do |vat|
+            rows << "\"#{vat[0..1]}\",\"#{vat[2..-1]}\",\"#{requester_cc}\",\"#{requester_vat}\""
+          end
+          "#{rows.join("\n")}\n"
+        end
+
+        def upload(csv_content)
+          uri = URI.parse(BATCH_API_URL)
+          boundary = "EuropeGem#{SecureRandom.hex(16)}"
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+            request = Net::HTTP::Post.new(uri.request_uri)
+            request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+            request['Accept'] = 'application/json'
+            request.body = build_multipart_body(csv_content, boundary)
+            http.request(request)
+          end
+        end
+
+        def build_multipart_body(csv_content, boundary)
+          "--#{boundary}\r\n" \
+            "Content-Disposition: form-data; name=\"fileToUpload\"; filename=\"batch.csv\"\r\n" \
+            "Content-Type: text/csv\r\n\r\n" \
+            "#{csv_content}" \
+            "\r\n--#{boundary}--\r\n"
+        end
+      end
+    end
+  end
+end

data/lib/europe/vat/rates.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
-require 'rexml/document'
+require 'json'
 
 module Europe
   module Vat
     # Rates
     module Rates
       FALLBACK_RATES = {
-        AT: 20.0, BE: 21.0, BG: 20.0, CY: 19.0, CZ: 21.0, DE: 19.0, DK: 25.0, EE: 22.0,
+        AT: 20.0, BE: 21.0, BG: 20.0, CY: 19.0, CZ: 21.0, DE: 19.0, DK: 25.0, EE: 24.0,
         EL: 24.0, ES: 21.0, FI: 25.5, FR: 20.0, HR: 25.0, HU: 27.0, IE: 23.0,
         IT: 22.0, LT: 21.0, LU: 17.0, LV: 21.0, MT: 18.0, NL: 21.0, PL: 23.0, PT: 23.0,
-        RO: 19.0, SE: 25.0, SI: 22.0, SK: 23.0
+        RO: 21.0, SE: 25.0, SI: 22.0, SK: 23.0
       }.freeze
-      RATES_URL = 'https://europa.eu/youreurope/business/taxation/vat' \
-                  '/vat-rules-rates/index_en.htm'
+      RATES_URL = 'https://raw.githubusercontent.com/benbucksch/eu-vat-rates' \
+                  '/refs/heads/master/rates.json'
+
+      COUNTRY_CODE_MAP = { GR: :EL }.freeze
 
       def self.retrieve
         resp = fetch_rates
@@ -22,33 +24,16 @@ module Europe
         extract_rates(resp)
       end
 
-      # rubocop:disable Metrics/MethodLength
       def self.extract_rates(resp)
+        data = JSON.parse(resp)
         rates = {}
-
-        begin
-          data = resp.scan(%r{\<tbody\>(.*)\<\/tbody\>}m).first.first.strip
-        rescue NoMethodError
-          return FALLBACK_RATES
-        end
-
-        xml = REXML::Document.new("<root>#{data}</root>")
-        xml.first.elements.each('tr') do |result|
-          next if result[3].nil?
-
-          rates = filter_rate(result, rates || {})
+        data['rates'].each do |code, info|
+          key = COUNTRY_CODE_MAP[code.to_sym] || code.to_sym
+          rates[key] = info['standard_rate'].to_f
         end
         rates
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      def self.filter_rate(result, rates)
-        return unless result[1].text.size == 2
-
-        country = result[1].text
-        rate = result[5].text
-        rates[country.to_sym] = rate.to_f if country && rate
-        rates
+      rescue JSON::ParserError
+        FALLBACK_RATES
       end
 
       def self.fetch_rates

data/lib/europe/vat/vat.rb

@@ -2,79 +2,98 @@
 
 require 'europe/vat/rates'
 require 'europe/vat/format'
+require 'europe/vat/batch'
 require 'uri'
 require 'net/http'
-require 'rexml/document'
+require 'json'
 require 'date'
 
 # Europe Gem
 module Europe
   # VAT
   module Vat
-    WSDL = 'http://ec.europa.eu/taxation_customs/vies/' \
-           'services/checkVatService'
+    API_URL = 'https://ec.europa.eu/taxation_customs/vies/rest-api/check-vat-number'
     HEADERS = {
-      'Content-Type' => 'text/xml;charset=UTF-8',
-      'SOAPAction' => ''
+      'Content-Type' => 'application/json',
+      'Accept' => 'application/json'
     }.freeze
 
-    BODY = <<-XML
-      <soapenv:Envelope
-      xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
-      xmlns:urn="urn:ec.europa.eu:taxud:vies:services:checkVat:types">
-        <soapenv:Header/>
-        <soapenv:Body>
-           <urn:checkVat>
-              <urn:countryCode>{COUNTRY_CODE}</urn:countryCode>
-              <urn:vatNumber>{NUMBER}</urn:vatNumber>
-           </urn:checkVat>
-        </soapenv:Body>
-      </soapenv:Envelope>
-    XML
+    VIES_ERRORS = {
+      'INVALID_INPUT' => :invalid_input,
+      'GLOBAL_MAX_CONCURRENT_REQ' => :rate_limited,
+      'MS_MAX_CONCURRENT_REQ' => :rate_limited,
+      'SERVICE_UNAVAILABLE' => :service_unavailable,
+      'MS_UNAVAILABLE' => :ms_unavailable,
+      'TIMEOUT' => :timeout
+    }.freeze
 
     def self.validate(number)
-      return :failed if number.size < 4
+      return :invalid_input if number.size < 4
 
       response = send_request(number[0..1], number[2..-1])
-      return :failed unless response.is_a? Net::HTTPSuccess
-      return :failed if response.body.include?('soap:Fault')
-      return :timeout if response.body.include?('TIMEOUT')
-      return :timeout if response.body.include?('MS_MAX_CONCURRENT_REQ')
+      return handle_error_response(response) unless response.is_a?(Net::HTTPSuccess)
+
+      setup_response(response)
+    rescue Net::OpenTimeout, Net::ReadTimeout
+      :timeout
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, SocketError, OpenSSL::SSL::SSLError
+      :service_unavailable
+    end
+
+    def self.validate_with_country_code(country_code, number)
+      return :invalid_input if number.size < 4
+
+      # Remove country code from number if it's present
+      number = number[2..-1] if number[0..1].upcase.to_s == country_code.to_s
+
+      response = send_request(country_code, number)
+      return handle_error_response(response) unless response.is_a?(Net::HTTPSuccess)
 
       setup_response(response)
-    rescue Net::OpenTimeout
+    rescue Net::OpenTimeout, Net::ReadTimeout
       :timeout
-    rescue Net::HTTPServerError
-      :server_error
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, SocketError, OpenSSL::SSL::SSLError
+      :service_unavailable
+    end
+
+    def self.batch_validate(vat_numbers, requester: nil)
+      Batch.validate(vat_numbers, requester: requester)
+    end
+
+    def self.batch_status(token)
+      Batch.status(token)
+    end
+
+    def self.batch_result(token)
+      Batch.result(token)
+    end
+
+    def self.handle_error_response(response)
+      body = JSON.parse(response.body)
+      error_code = body.dig('errorWrappers', 0, 'error')
+      VIES_ERRORS[error_code] || :service_error
+    rescue JSON::ParserError
+      :service_error
     end
 
     def self.setup_response(response)
-      body = response_xml(response)
+      body = JSON.parse(response.body)
       {
-        valid: extract_data(body, 3) == 'true',
-        country_code: extract_data(body, 0),
-        vat_number: extract_data(body, 1),
-        request_date: convert_date(extract_data(body, 2)),
-        name: extract_data(body, 4),
-        address: extract_data(body, 5)
+        valid: body['valid'] == true,
+        country_code: body['countryCode'],
+        vat_number: body['vatNumber'],
+        request_date: convert_date(body['requestDate']),
+        name: body['name'],
+        address: body['address']
       }
     end
 
-    def self.response_xml(response)
-      xml = REXML::Document.new(response.body)
-      xml.elements.first.elements[2].elements[1]
-    end
-
     def self.convert_date(date)
       return unless date
 
       Date.parse(date)
     end
 
-    def self.extract_data(body, position)
-      body[position]&.text
-    end
-
     def self.charge_vat?(origin_country, number)
       return false if number.nil? || number.empty?
 
@@ -83,18 +102,16 @@ module Europe
     end
 
     def self.send_request(country_code, number)
-      uri = URI.parse(WSDL)
-
-      body = BODY.dup.gsub('{COUNTRY_CODE}', country_code)
-      body = body.gsub('{NUMBER}', number)
-
-      # Create the HTTP objects
-      http = Net::HTTP.new(uri.host, uri.port)
-      request = Net::HTTP::Post.new(uri.request_uri, HEADERS)
-      request.body = body
-
-      # Send the request
-      http.request(request)
+      uri = URI.parse(API_URL)
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        request = Net::HTTP::Post.new(uri.request_uri, HEADERS)
+        request.body = JSON.generate(
+          countryCode: country_code,
+          vatNumber: number
+        )
+        http.request(request)
+      end
     end
   end
 end

data/lib/europe/version.rb

@@ -2,5 +2,5 @@
 
 # Europe version
 module Europe
-  VERSION = '0.0.26'
+  VERSION = '0.0.28'
 end

data/test/europe/vat/batch_validation_test.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Europe
+  module Vat
+    BATCH_SUCCESS_BODY = '{"token":"test-token-uuid"}'
+    BATCH_STRUCTURE_ERROR_BODY = '{"actionSucceed":false,"errorWrappers":' \
+                                 '[{"error":"VOW-ERR-6008","message":' \
+                                 '"Your file does not match the expected structure"}]}'
+    BATCH_TOKEN_NOT_FOUND_BODY = '{"actionSucceed":false,"errorWrappers":' \
+                                 '[{"error":"VOW-ERR-6006","message":' \
+                                 '"The token is not valid"}]}'
+    BATCH_STATUS_PROCESSING_BODY = '{"token":"test-token-uuid","filename":"batch.csv",' \
+                                   '"creationDateTime":"2026-06-08T09:47:13.720Z",' \
+                                   '"status":"PROCESSING","processingStartTime":' \
+                                   '"2026-06-08T09:47:13.852Z","percentage":66.67}'
+    BATCH_STATUS_COMPLETED_BODY = '{"token":"test-token-uuid","filename":"batch.csv",' \
+                                  '"creationDateTime":"2026-06-08T09:47:13.720Z",' \
+                                  '"status":"COMPLETED","processingStartTime":' \
+                                  '"2026-06-08T09:47:13.852Z","completionTime":' \
+                                  '"2026-06-08T09:47:49.937Z","percentage":100.0}'
+
+    class BatchValidationTest < Minitest::Test
+      VAT_NUMBERS = %w[NL009291477B01 DE115235681 FR40303265045].freeze
+
+      def setup
+        WebMock.enable!
+      end
+
+      def teardown
+        WebMock.disable!
+      end
+
+      def test_batch_validate_returns_token
+        stub_request(:post, Europe::Vat::Batch::BATCH_API_URL)
+          .to_return(status: 200, body: BATCH_SUCCESS_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        result = Europe::Vat::Batch.validate(VAT_NUMBERS)
+        assert_equal({ token: 'test-token-uuid' }, result)
+      end
+
+      def test_batch_validate_too_few_rows
+        assert_equal :too_few_rows, Europe::Vat::Batch.validate(%w[NL009291477B01 DE115235681])
+      end
+
+      def test_batch_validate_too_many_rows
+        numbers = (1..101).map { |i| "NL#{i.to_s.rjust(12, '0')}" }
+        assert_equal :too_many_rows, Europe::Vat::Batch.validate(numbers)
+      end
+
+      def test_batch_validate_with_requester
+        stub_request(:post, Europe::Vat::Batch::BATCH_API_URL)
+          .with { |req| req.body.include?('NL') && req.body.include?('009291477B01') }
+          .to_return(status: 200, body: BATCH_SUCCESS_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        result = Europe::Vat::Batch.validate(VAT_NUMBERS, requester: 'NL009291477B01')
+        assert_equal({ token: 'test-token-uuid' }, result)
+      end
+
+      def test_batch_validate_structure_error
+        stub_request(:post, Europe::Vat::Batch::BATCH_API_URL)
+          .to_return(status: 400, body: BATCH_STRUCTURE_ERROR_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        assert_equal :invalid_file_structure, Europe::Vat::Batch.validate(VAT_NUMBERS)
+      end
+
+      def test_batch_validate_timeout
+        stub_request(:post, Europe::Vat::Batch::BATCH_API_URL).to_timeout
+
+        assert_equal :timeout, Europe::Vat::Batch.validate(VAT_NUMBERS)
+      end
+
+      def test_batch_validate_connection_refused
+        stub_request(:post, Europe::Vat::Batch::BATCH_API_URL).to_raise(Errno::ECONNREFUSED)
+
+        assert_equal :service_unavailable, Europe::Vat::Batch.validate(VAT_NUMBERS)
+      end
+
+      def test_batch_status_processing
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_API_URL}/test-token-uuid")
+          .to_return(status: 200, body: BATCH_STATUS_PROCESSING_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        result = Europe::Vat::Batch.status('test-token-uuid')
+        assert_equal :processing, result[:status]
+        assert_equal 66.67, result[:percentage]
+      end
+
+      def test_batch_status_completed
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_API_URL}/test-token-uuid")
+          .to_return(status: 200, body: BATCH_STATUS_COMPLETED_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        result = Europe::Vat::Batch.status('test-token-uuid')
+        assert_equal :completed, result[:status]
+        assert_equal 100.0, result[:percentage]
+        assert_equal 'test-token-uuid', result[:token]
+        refute_nil result[:completed_at]
+      end
+
+      def test_batch_status_invalid_token
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_API_URL}/bad-token")
+          .to_return(status: 400, body: BATCH_TOKEN_NOT_FOUND_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        assert_equal :token_not_found, Europe::Vat::Batch.status('bad-token')
+      end
+
+      def test_batch_status_timeout
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_API_URL}/test-token-uuid").to_timeout
+
+        assert_equal :timeout, Europe::Vat::Batch.status('test-token-uuid')
+      end
+
+      def test_batch_result_returns_data
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_REPORT_URL}/test-token-uuid")
+          .to_return(
+            status: 200,
+            body: 'fake-xlsx-binary-data',
+            headers: {
+              'Content-Type' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+              'Content-Disposition' => 'attachment; filename="report.xlsx"'
+            }
+          )
+
+        result = Europe::Vat::Batch.result('test-token-uuid')
+        assert_equal 'fake-xlsx-binary-data', result[:data]
+        assert_equal 'report.xlsx', result[:filename]
+        assert result[:content_type].include?('spreadsheetml')
+      end
+
+      def test_batch_result_invalid_token
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_REPORT_URL}/bad-token")
+          .to_return(status: 400, body: BATCH_TOKEN_NOT_FOUND_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        assert_equal :token_not_found, Europe::Vat::Batch.result('bad-token')
+      end
+
+      def test_batch_result_timeout
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_REPORT_URL}/test-token-uuid").to_timeout
+
+        assert_equal :timeout, Europe::Vat::Batch.result('test-token-uuid')
+      end
+
+      def test_generate_batch_csv_format
+        csv = Europe::Vat::Batch.send(:generate_csv, VAT_NUMBERS, nil)
+        lines = csv.strip.split("\n")
+
+        assert_equal 4, lines.size
+        assert_equal '"MS Code","VAT Number","Requester MS Code","Requester VAT Number"', lines[0]
+        assert_equal '"NL","009291477B01","",""', lines[1]
+        assert_equal '"DE","115235681","",""', lines[2]
+        assert_equal '"FR","40303265045","",""', lines[3]
+      end
+
+      def test_generate_batch_csv_with_requester
+        csv = Europe::Vat::Batch.send(:generate_csv, VAT_NUMBERS, 'NL009291477B01')
+        lines = csv.strip.split("\n")
+
+        assert_equal '"NL","009291477B01","NL","009291477B01"', lines[1]
+      end
+
+      # Delegation tests — ensure Europe::Vat.batch_* still works
+      def test_delegation_batch_validate
+        stub_request(:post, Europe::Vat::Batch::BATCH_API_URL)
+          .to_return(status: 200, body: BATCH_SUCCESS_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        result = Europe::Vat.batch_validate(VAT_NUMBERS)
+        assert_equal({ token: 'test-token-uuid' }, result)
+      end
+
+      def test_delegation_batch_status
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_API_URL}/test-token-uuid")
+          .to_return(status: 200, body: BATCH_STATUS_COMPLETED_BODY,
+                     headers: { 'Content-Type' => 'application/json' })
+
+        result = Europe::Vat.batch_status('test-token-uuid')
+        assert_equal :completed, result[:status]
+      end
+
+      def test_delegation_batch_result
+        stub_request(:get, "#{Europe::Vat::Batch::BATCH_REPORT_URL}/test-token-uuid")
+          .to_return(
+            status: 200,
+            body: 'fake-xlsx-binary-data',
+            headers: {
+              'Content-Type' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+              'Content-Disposition' => 'attachment; filename="report.xlsx"'
+            }
+          )
+
+        result = Europe::Vat.batch_result('test-token-uuid')
+        assert_equal 'fake-xlsx-binary-data', result[:data]
+      end
+    end
+  end
+end

data/test/europe/vat/validation_test.rb

@@ -4,6 +4,25 @@ require 'test_helper'
 
 module Europe
   module Vat
+    SERVICE_UNAVAILABLE_BODY = '{"actionSucceed":false,"errorWrappers":' \
+                               '[{"error":"SERVICE_UNAVAILABLE","message":' \
+                               '"An error was encountered either at the national ' \
+                               'level or at the European Commission"}]}'
+    MS_UNAVAILABLE_BODY = '{"actionSucceed":false,"errorWrappers":' \
+                          '[{"error":"MS_UNAVAILABLE","message":"The Member State service is unavailable"}]}'
+    GLOBAL_RATE_LIMITED_BODY = '{"actionSucceed":false,"errorWrappers":' \
+                               '[{"error":"GLOBAL_MAX_CONCURRENT_REQ","message":' \
+                               '"Your Request for VAT validation has not been processed; ' \
+                               'your max. number of concurrent requests has been reached"}]}'
+    MS_RATE_LIMITED_BODY = '{"actionSucceed":false,"errorWrappers":' \
+                           '[{"error":"MS_MAX_CONCURRENT_REQ","message":' \
+                           '"Your Request for VAT validation has not been processed; ' \
+                           'your max. number of concurrent requests for this Member State has been reached"}]}'
+    INVALID_INPUT_BODY = '{"actionSucceed":false,"errorWrappers":' \
+                         '[{"error":"INVALID_INPUT","message":"The provided CountryCode is invalid"}]}'
+    VIES_TIMEOUT_BODY = '{"actionSucceed":false,"errorWrappers":' \
+                        '[{"error":"TIMEOUT","message":"The Member State service could not be reached in time"}]}'
+
     # ValidationTest
     class ValidationTest < Minitest::Test
       include Benchmark
@@ -13,7 +32,7 @@ module Europe
       end
 
       def test_validation_of_short_vat_number
-        assert_equal :failed, Europe::Vat.validate('6')
+        assert_equal :invalid_input, Europe::Vat.validate('6')
       end
 
       def test_validation_of_false_vat_number
@@ -29,23 +48,76 @@ module Europe
         # PostNL
         validate_correct_vat = Europe::Vat.validate('NL009291477B01')
         assert validate_correct_vat[:valid] \
-          unless %i[timeout failed].include?(validate_correct_vat)
+          unless validate_correct_vat.is_a?(Symbol)
 
         # Volkswagen
         validate_correct_vat = Europe::Vat.validate('DE115235681')
         assert validate_correct_vat[:valid] \
-          unless %i[timeout failed].include?(validate_correct_vat)
+          unless validate_correct_vat.is_a?(Symbol)
       end
 
-      def test_failed_request_to_soap_service
+      def test_timeout
         WebMock.enable!
-        stub_request(:any, 'http://ec.europa.eu/taxation_customs/vies/services/checkVatService').to_timeout
-        Europe::Vat.validate('DE115235681')
+        stub_request(:post, Europe::Vat::API_URL).to_timeout
+        assert_equal :timeout, Europe::Vat.validate('DE115235681')
+        WebMock.disable!
+      end
+
+      def test_connection_refused
+        WebMock.enable!
+        stub_request(:post, Europe::Vat::API_URL).to_raise(Errno::ECONNREFUSED)
+        assert_equal :service_unavailable, Europe::Vat.validate('DE115235681')
+        WebMock.disable!
+      end
+
+      def test_server_error_without_body
+        WebMock.enable!
+        stub_request(:post, Europe::Vat::API_URL)
+          .to_return(status: 500, body: '')
+        assert_equal :service_error, Europe::Vat.validate('DE115235681')
+        WebMock.disable!
+      end
+
+      def test_service_unavailable_error
+        assert_vies_error 500, SERVICE_UNAVAILABLE_BODY,
+                          'DE115235681', :service_unavailable
+      end
 
-        stub_request(:get, 'http://ec.europa.eu/taxation_customs/vies/services/checkVatService')
-          .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
-          .to_return(status: 421, body: '')
-        Europe::Vat.validate('DE115235681')
+      def test_ms_unavailable_error
+        assert_vies_error 500, MS_UNAVAILABLE_BODY,
+                          'DE115235681', :ms_unavailable
+      end
+
+      def test_rate_limited_global
+        assert_vies_error 500, GLOBAL_RATE_LIMITED_BODY,
+                          'DE115235681', :rate_limited
+      end
+
+      def test_rate_limited_member_state
+        assert_vies_error 500, MS_RATE_LIMITED_BODY,
+                          'DE115235681', :rate_limited
+      end
+
+      def test_invalid_input_error
+        assert_vies_error 400, INVALID_INPUT_BODY,
+                          'XX123456789', :invalid_input
+      end
+
+      def test_vies_timeout_error
+        assert_vies_error 500, VIES_TIMEOUT_BODY,
+                          'DE115235681', :timeout
+      end
+
+      private
+
+      def assert_vies_error(status, body, vat, expected)
+        WebMock.enable!
+        stub_request(:post, Europe::Vat::API_URL)
+          .to_return(
+            status: status, body: body,
+            headers: { 'Content-Type' => 'application/json' }
+          )
+        assert_equal expected, Europe::Vat.validate(vat)
         WebMock.disable!
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: europe
 version: !ruby/object:Gem::Version
-  version: 0.0.26
+  version: 0.0.28
 platform: ruby
 authors:
 - Gem shards
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-15 00:00:00.000000000 Z
+date: 2026-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -165,6 +165,7 @@ files:
 - lib/europe/postal/postal.rb
 - lib/europe/rake_task.rb
 - lib/europe/tasks/eurostat.rake
+- lib/europe/vat/batch.rb
 - lib/europe/vat/format.rb
 - lib/europe/vat/rates.rb
 - lib/europe/vat/vat.rb
@@ -174,6 +175,7 @@ files:
 - test/europe/currency/exchange_rates_test.rb
 - test/europe/eurostat/eurostat_test.rb
 - test/europe/postal/format_test.rb
+- test/europe/vat/batch_validation_test.rb
 - test/europe/vat/format_test.rb
 - test/europe/vat/rates_test.rb
 - test/europe/vat/validation_test.rb
@@ -199,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Europe is a gem for retrieving and validating EU government data.
@@ -209,6 +211,7 @@ test_files:
 - test/europe/currency/exchange_rates_test.rb
 - test/europe/eurostat/eurostat_test.rb
 - test/europe/postal/format_test.rb
+- test/europe/vat/batch_validation_test.rb
 - test/europe/vat/format_test.rb
 - test/europe/vat/rates_test.rb
 - test/europe/vat/validation_test.rb