valvat 1.0.1 → 1.1.0

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|
+  %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)
+      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)
+      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,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Checksum::RO do
-  %w(RO123456789 RO99908 RO19 RO124 RO13182060).each do |valid_vat|
+  %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

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|
+  %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)
+      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)
+      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|
+  %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)
+      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)
+      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,27 @@
+# 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
 
 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)
+        expect(described_class.validate(valid_vat)).to be(true)
       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,257 +1,242 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Valvat::Lookup do
-  describe "#validate" do
-    context "existing VAT number" do
-
-      it "returns true" do
-        result = Valvat::Lookup.validate("IE6388047V")
-
-        unless result.nil?
-          expect(result).to eql(true)
-        else
-          puts "Skipping IE vies lookup spec"
-        end
+  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 "allows Valvat instance as input" do
-        result = Valvat::Lookup.validate(Valvat.new("IE6388047V"))
-
-        unless result.nil?
-          expect(result).to eql(true)
-        else
-          puts "Skipping IE vies lookup spec"
-        end
+      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
 
-    context "not existing VAT number" do
-      it "returns false" do
-        result =  Valvat::Lookup.validate("IE6388048V")
-
-        unless result.nil?
-          expect(result).to eql(false)
-        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
 
-    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)
+    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
-      it "returns hash of details instead of true" do
-        result = Valvat::Lookup.validate("IE6388047V", detail: true)
+    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
 
-         if result
+      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({
-            country_code: "IE",
-            vat_number: "6388047V",
-            name: "GOOGLE IRELAND LIMITED",
-            address: "3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4",
-            valid: true
-          })
-        else
-          puts "Skipping IE vies lookup spec; result = #{result.inspect}"
+          expect(result).to eql(details)
         end
       end
 
-      it "still returns false on not existing VAT number" do
-        result =  Valvat::Lookup.validate("LU21416128", detail: true)
-
-        unless result.nil?
-          expect(result).to eql(false)
-        else
-          puts "Skipping LU vies lookup spec"
-        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 "with request identifier" do
-      it "returns hash of details instead of true" do
-        response = Valvat::Lookup.validate("IE6388047V", requester: "IE6388047V")
+    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
 
+      it 'returns hash of details instead of true' do
+        # Skip if VIES is down
         if response
-          expect(response[:request_identifier].size).to eql(16)
-          request_identifier = response[:request_identifier]
+          expect(response.delete(:request_identifier).size).to be(16)
           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,
-            valid: true
-          })
-        else
-          puts "Skipping IE vies lookup spec"
+          expect(response).to eql(details)
         end
       end
 
-      it "supports old :requester_vat option for backwards stability" do
+      it 'supports old :requester_vat option for backwards stability' do
         expect(
-          Valvat::Lookup.new("IE6388047V", requester_vat: "LU21416127").instance_variable_get(:@options)[:requester]
-        ).to eql("LU21416127")
-
-        expect(
-          Valvat::Lookup.new("IE6388047V", requester: "LU21416128").instance_variable_get(:@options)[:requester]
-        ).to eql("LU21416128")
+          described_class.new('IE6388047V', requester_vat: 'LU21416127').instance_variable_get(:@options)[:requester]
+        ).to eql('LU21416127')
       end
     end
   end
 
-  describe "#validate with VIES test enviroment" do
-
-    let(:options) { {savon: {wsdl: "https://ec.europa.eu/taxation_customs/vies/checkVatTestService.wsdl"}, skip_local_validation: true} }
+  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 "Valid request with Valid VAT Number" do
-      subject{ Valvat::Lookup.validate("DE100", options) }
+    context 'with valid request with valid VAT number' do
+      subject(:result) { described_class.validate('DE100', options) }
 
-      it "returns true" do
-        expect(subject).to eql(true)
+      it 'returns true' do
+        expect(result).to be(true)
       end
     end
 
-    context "Valid request with an Invalid VAT Number" do
-      subject{ Valvat::Lookup.validate("DE200", options) }
+    context 'with valid request with an invalid VAT number' do
+      subject(:result) { described_class.validate('DE200', options) }
 
-      it "returns false" do
-        expect(subject).to eql(false)
+      it 'returns false' do
+        expect(result).to be(false)
       end
     end
 
-    context "Error : INVALID_INPUT" do
-      subject{ Valvat::Lookup.validate("DE201", options) }
+    describe 'Error : INVALID_INPUT' do
+      subject(:result) { described_class.validate('DE201', options) }
 
-      it "returns false" do
-        expect(subject).to eql(false)
+      it 'returns false' do
+        expect(result).to be(false)
       end
     end
 
-    context "Error : INVALID_REQUESTER_INFO" do
-      subject{ Valvat::Lookup.validate("DE202", options) }
+    describe 'Error : INVALID_REQUESTER_INFO' do
+      subject(:result) { described_class.validate('DE202', options) }
 
-      it "raises Valvat::InvalidRequester" do
-        expect{ subject }.to raise_error(Valvat::InvalidRequester)
+      it 'raises Valvat::InvalidRequester' do
+        expect { result }.to raise_error(Valvat::InvalidRequester)
       end
     end
 
-    context "Error : SERVICE_UNAVAILABLE" do
-      subject{ Valvat::Lookup.validate("DE300", options) }
+    describe 'Error : SERVICE_UNAVAILABLE' do
+      subject(:result) { described_class.validate('DE300', options) }
 
-      it "returns nil" do
-        expect(subject).to eql(nil)
+      it 'returns nil' do
+        expect(result).to be(nil)
       end
 
-      it "raises error with raise_error: true" do
-        expect{
-          Valvat::Lookup.validate("DE300", options.merge(raise_error: true)
-        ) }.to raise_error(Valvat::ServiceUnavailable)
+      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
 
-    context "Error : MS_UNAVAILABLE" do
-      subject{ Valvat::Lookup.validate("DE301", options) }
+    describe 'Error : MS_UNAVAILABLE' do
+      subject(:result) { described_class.validate('DE301', options) }
 
-      it "returns nil" do
-        expect(subject).to eql(nil)
+      it 'returns nil' do
+        expect(result).to be(nil)
       end
 
-      it "raises error with raise_error: true" do
-        expect{
-          Valvat::Lookup.validate("DE301", options.merge(raise_error: true)
-        ) }.to raise_error(Valvat::MemberStateUnavailable)
+      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 : TIMEOUT" do
-      subject{ Valvat::Lookup.validate("DE302", options) }
+    describe 'Error : TIMEOUT' do
+      subject(:result) { described_class.validate('DE302', options) }
 
-      it "raises error" do
-        expect{ subject }.to raise_error(Valvat::Timeout)
+      it 'raises error' do
+        expect { result }.to raise_error(Valvat::Timeout)
       end
 
-      it "returns nil with raise_error set to false" do
-        expect(Valvat::Lookup.validate("DE302", options.merge(raise_error: false))).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
 
-    context "Error : VAT_BLOCKED" do
-      subject{ Valvat::Lookup.validate("DE400", options) }
+    describe 'Error : VAT_BLOCKED' do
+      subject(:result) { described_class.validate('DE400', options) }
 
-      it "raises error" do
-        expect{ subject }.to raise_error(Valvat::BlockedError, /VAT_BLOCKED/)
+      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(Valvat::Lookup.validate("DE400", options.merge(raise_error: false))).to eql(nil)
+      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
 
-    context "Error : IP_BLOCKED" do
-      subject{ Valvat::Lookup.validate("DE401", options) }
+    describe 'Error : IP_BLOCKED' do
+      subject(:result) { described_class.validate('DE401', options) }
 
-      it "raises error" do
-        expect{ subject }.to raise_error(Valvat::BlockedError, /IP_BLOCKED/)
+      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(Valvat::Lookup.validate("DE401", options.merge(raise_error: false))).to eql(nil)
+      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
 
-    context "Error : GLOBAL_MAX_CONCURRENT_REQ" do
-      subject{ Valvat::Lookup.validate("DE500", options) }
+    describe 'Error : GLOBAL_MAX_CONCURRENT_REQ' do
+      subject(:result) { described_class.validate('DE500', options) }
 
-      it "raises error" do
-        expect{ subject }.to raise_error(Valvat::RateLimitError, /GLOBAL_MAX_CONCURRENT_REQ/)
+      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(Valvat::Lookup.validate("DE500", options.merge(raise_error: false))).to eql(nil)
+      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
 
-    context "Error : GLOBAL_MAX_CONCURRENT_REQ_TIME" do
-      subject{ Valvat::Lookup.validate("DE501", options) }
+    describe 'Error : GLOBAL_MAX_CONCURRENT_REQ_TIME' do
+      subject(:result) { described_class.validate('DE501', options) }
 
-      it "raises error" do
-        expect{ subject }.to raise_error(Valvat::RateLimitError, /GLOBAL_MAX_CONCURRENT_REQ_TIME/)
+      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(Valvat::Lookup.validate("DE501", options.merge(raise_error: false))).to eql(nil)
+      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
 
-    context "Error : MS_MAX_CONCURRENT_REQ" do
-      subject{ Valvat::Lookup.validate("DE600", options) }
+    describe 'Error : MS_MAX_CONCURRENT_REQ' do
+      subject(:result) { described_class.validate('DE600', options) }
 
-      it "raises error" do
-        expect{ subject }.to raise_error(Valvat::RateLimitError, /MS_MAX_CONCURRENT_REQ/)
+      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(Valvat::Lookup.validate("DE600", options.merge(raise_error: false))).to eql(nil)
+      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
 
-    context "Error : MS_MAX_CONCURRENT_REQ_TIME" do
-      subject{ Valvat::Lookup.validate("DE601", options) }
+    describe 'Error : MS_MAX_CONCURRENT_REQ_TIME' do
+      subject(:result) { described_class.validate('DE601', options) }
 
-      it "raises error" do
-        expect{ subject }.to raise_error(Valvat::RateLimitError, /MS_MAX_CONCURRENT_REQ_TIME/)
+      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(Valvat::Lookup.validate("DE601", options.merge(raise_error: false))).to eql(nil)
+      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