europe 0.0.27 → 0.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0918fb1141de821b11aff7fb2d11da6ef7c75b2870e3b90a1373cfd26dc5fbe
-  data.tar.gz: f7b250f54690746d5339f6209625238461b7dd7edcc4d58adad5e095660186be
+  metadata.gz: 296e93d88ac5b6bf8a62eb5247a2bdd06b5c6d6062d76f2cc8c334022b7d5d61
+  data.tar.gz: a47e82a08f0a4c62d515dab2cb3ad6fc522cb425d99a7ceed13f890671f28533
 SHA512:
-  metadata.gz: f57c86ea54e7539887b3f8674035bca535379c5fcc1b532e4a995f0d67c3435f34e5195487db2ecabbbe6c3a0d1846ae70b232ce18ab9d2436dadd2bb7ef6864
-  data.tar.gz: d05a4f28813638f846d0e507c60e7f4f731d843914448c85b68ad3b4011f61784bb8dd15a501fd5bfdbd2c21c79ba7aa2692f47bece6701444dbf09bb77276a3
+  metadata.gz: f4c3d6bf252d2c593e86d640889f03d198928e31cb5fe9a70bdb45a69962a6bc87818b15c4436230b1d55451344a1373f19cdc214cb60e87ca8b9cb2b468f2c5
+  data.tar.gz: 8e4b235296425351f3a617a768356ea04f26cb566a1e22dba4153df080cb07733006aa03521139d8e1314ed71a59509e72350c020c783070af7c5452ab7dfe0f

data/.rubocop.yml

@@ -19,3 +19,15 @@ Style/CaseLikeIf:
 
 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,13 @@
 # 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.29
+  - Added Croatia to Eurozone (oops!)
+  - [Full Changelog](https://github.com/gem-shards/europe.rb/compare/v0.0.28...v0.0.29)
+## 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

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/countries/countries.rb

@@ -41,7 +41,7 @@ module Europe
             tld: '.fr', currency: :EUR, capital: 'Paris' },
       HR: { name: 'Croatia', source_name: 'Hrvatska',
             official_name: 'Republic of Croatia',
-            tld: '.hr', currency: :HRK, capital: 'Zagreb' },
+            tld: '.hr', currency: :EUR, capital: 'Zagreb' },
       IT: { name: 'Italy', source_name: 'Italia',
             official_name: 'Italian Republic',
             tld: '.it', currency: :EUR, capital: 'Rome' },

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

@@ -7,10 +7,10 @@ module Europe
     # 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://raw.githubusercontent.com/benbucksch/eu-vat-rates' \
                   '/refs/heads/master/rates.json'

data/lib/europe/vat/vat.rb

@@ -2,6 +2,7 @@
 
 require 'europe/vat/rates'
 require 'europe/vat/format'
+require 'europe/vat/batch'
 require 'uri'
 require 'net/http'
 require 'json'
@@ -39,6 +40,34 @@ module Europe
       :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, Net::ReadTimeout
+      :timeout
+    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')

data/lib/europe/version.rb

@@ -2,5 +2,5 @@
 
 # Europe version
 module Europe
-  VERSION = '0.0.27'
+  VERSION = '0.0.29'
 end

data/test/europe/countries/country_test.rb

@@ -16,7 +16,7 @@ module Europe
 
         reversed_hash =
           Europe::Countries::Reversed.generate(:currency)
-        assert_equal reversed_hash[:EUR].count, 19
+        assert_equal reversed_hash[:EUR].count, 20
       end
 
       def test_eurozone

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: europe
 version: !ruby/object:Gem::Version
-  version: 0.0.27
+  version: 0.0.29
 platform: ruby
 authors:
 - Gem shards
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -165,6 +164,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 +174,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
@@ -184,7 +185,6 @@ licenses:
 metadata:
   source_code_uri: https://github.com/gem-shards/europe.rb
   changelog_uri: https://github.com/gem-shards/europe.rb/blob/master/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -199,8 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Europe is a gem for retrieving and validating EU government data.
 test_files:
@@ -209,6 +208,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