valvat 0.8.1 → 1.0.1

data/spec/valvat/checksum_spec.rb

@@ -8,7 +8,7 @@ end
 
 describe Valvat::Checksum do
   describe "#validate" do
-    it "returns true on vat number with unknown checksum algorithm" do
+    it "returns true on VAT number with unknown checksum algorithm" do
       expect(Valvat::Checksum.validate("CZ699001237")).to eql(true)
     end
 
@@ -17,7 +17,7 @@ describe Valvat::Checksum do
     end
 
     VALID_VAT_NUMBERS.each do |valid_vat|
-      it "returns true on valid vat number #{valid_vat}" do
+      it "returns true on valid VAT number #{valid_vat}" do
         expect(Valvat::Checksum.validate(valid_vat)).to eql(true)
       end
     end

data/spec/valvat/lockup/fault_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Valvat::Lookup::Fault do
+  it "returns {valid: false} on fault 'INVALID_INPUT'" do
+    expect(Valvat::Lookup::Fault.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(Valvat::Lookup::Fault.new({
+        fault: {faultstring: fault}
+      }).to_hash).to eql({
+        error: error.new(fault)
+      })
+    end
+  end
+end

data/spec/valvat/lockup/request_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Valvat::Lookup::Request do
+  it "returns Response on success" do
+    response = Valvat::Lookup::Request.new("IE6388047V", {}).perform
+    expect(response).to be_a(Valvat::Lookup::Response)
+    expect(response.to_hash[:name]).to eql("GOOGLE IRELAND LIMITED")
+  end
+
+  it "returns Fault on failure" do
+    response = Valvat::Lookup::Request.new("XC123123", {}).perform
+    expect(response).to be_a(Valvat::Lookup::Fault)
+    expect(response.to_hash).to eql({valid: false})
+  end
+end

data/spec/valvat/lockup/response_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Valvat::Lookup::Response do
+  it "removes @xmlns from :check_vat_response hash" do
+    expect(Valvat::Lookup::Response.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(Valvat::Lookup::Response.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(Valvat::Lookup::Response.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(Valvat::Lookup::Response.new({
+      check_vat_response: {:a => 123, :b => 2}
+    })[:a]).to eql(123)
+  end
+end

data/spec/valvat/lookup_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Valvat::Lookup do
   describe "#validate" do
-    context "existing vat number" do
+    context "existing VAT number" do
 
       it "returns true" do
         result = Valvat::Lookup.validate("IE6388047V")
@@ -25,7 +25,7 @@ describe Valvat::Lookup do
       end
     end
 
-    context "not existing vat number" do
+    context "not existing VAT number" do
       it "returns false" do
         result =  Valvat::Lookup.validate("IE6388048V")
 
@@ -46,23 +46,24 @@ describe Valvat::Lookup do
 
     context "with details" do
       it "returns hash of details instead of true" do
-        result = Valvat::Lookup.validate("IE6388047V", :detail => true)
+        result = Valvat::Lookup.validate("IE6388047V", detail: true)
 
          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"
+            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}"
         end
       end
 
-      it "still returns false on not existing vat number" do
-        result =  Valvat::Lookup.validate("LU21416128", :detail => true)
+      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)
@@ -74,52 +75,184 @@ describe Valvat::Lookup do
 
     context "with request identifier" do
       it "returns hash of details instead of true" do
-        response = Valvat::Lookup.validate("IE6388047V", :requester_vat => "IE6388047V")
+        response = Valvat::Lookup.validate("IE6388047V", requester: "IE6388047V")
 
         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
+            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"
         end
       end
+
+      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")
+      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} }
+
+    context "Valid request with Valid VAT Number" do
+      subject{ Valvat::Lookup.validate("DE100", options) }
+
+      it "returns true" do
+        expect(subject).to eql(true)
+      end
+    end
+
+    context "Valid request with an Invalid VAT Number" do
+      subject{ Valvat::Lookup.validate("DE200", options) }
+
+      it "returns false" do
+        expect(subject).to eql(false)
+      end
+    end
+
+    context "Error : INVALID_INPUT" do
+      subject{ Valvat::Lookup.validate("DE201", options) }
+
+      it "returns false" do
+        expect(subject).to eql(false)
+      end
+    end
+
+    context "Error : INVALID_REQUESTER_INFO" do
+      subject{ Valvat::Lookup.validate("DE202", options) }
+
+      it "raises Valvat::InvalidRequester" do
+        expect{ subject }.to raise_error(Valvat::InvalidRequester)
+      end
+    end
+
+    context "Error : SERVICE_UNAVAILABLE" do
+      subject{ Valvat::Lookup.validate("DE300", options) }
+
+      it "returns nil" do
+        expect(subject).to eql(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)
+      end
+    end
+
+    context "Error : MS_UNAVAILABLE" do
+      subject{ Valvat::Lookup.validate("DE301", options) }
+
+      it "returns nil" do
+        expect(subject).to eql(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)
+      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)
+    context "Error : TIMEOUT" do
+      subject{ Valvat::Lookup.validate("DE302", options) }
+
+      it "raises error" do
+        expect{ subject }.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)
+      end
+    end
+
+    context "Error : VAT_BLOCKED" do
+      subject{ Valvat::Lookup.validate("DE400", options) }
+
+      it "raises error" do
+        expect{ subject }.to raise_error(Valvat::BlockedError, /VAT_BLOCKED/)
       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(Valvat::Lookup.validate("DE400", options.merge(raise_error: false))).to eql(nil)
       end
+    end
+
+    context "Error : IP_BLOCKED" do
+      subject{ Valvat::Lookup.validate("DE401", 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{ subject }.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)
       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
+    context "Error : GLOBAL_MAX_CONCURRENT_REQ" do
+      subject{ Valvat::Lookup.validate("DE500", options) }
+
+      it "raises error" do
+        expect{ subject }.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)
+      end
+    end
 
-    #   it "returns nil" do
-    #     Valvat::Lookup.validate("DE259597697").should eql(nil)
-    #   end
-    # end
+    context "Error : GLOBAL_MAX_CONCURRENT_REQ_TIME" do
+      subject{ Valvat::Lookup.validate("DE501", options) }
+
+      it "raises error" do
+        expect{ subject }.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)
+      end
+    end
+
+    context "Error : MS_MAX_CONCURRENT_REQ" do
+      subject{ Valvat::Lookup.validate("DE600", options) }
+
+      it "raises error" do
+        expect{ subject }.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)
+      end
+    end
+
+    context "Error : MS_MAX_CONCURRENT_REQ_TIME" do
+      subject{ Valvat::Lookup.validate("DE601", options) }
+
+      it "raises error" do
+        expect{ subject }.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)
+      end
+    end
   end
 end

data/spec/valvat/syntax_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Valvat::Syntax do
   describe "#validate" do
-    it "validates a DE vat number" do
+    it "validates a DE VAT number" do
       expect(subject.validate("DE345889003")).to eql(true)
 
       expect(subject.validate("DE34588900")).to eql(false)
@@ -10,7 +10,7 @@ describe Valvat::Syntax do
       expect(subject.validate("DE34588900C")).to eql(false)
     end
 
-    it "validates a AT vat number" do
+    it "validates a AT VAT number" do
       expect(subject.validate("ATU03458890")).to eql(true)
 
       expect(subject.validate("ATU034588908")).to eql(false)
@@ -18,7 +18,7 @@ describe Valvat::Syntax do
       expect(subject.validate("ATU0345889Y")).to eql(false)
     end
 
-    it "should validate BE vat number" do
+    it "should validate BE VAT number" do
       expect(subject.validate("BE0817331995")).to eql(true)
 
       expect(subject.validate("BE081733199")).to eql(false)
@@ -27,7 +27,7 @@ describe Valvat::Syntax do
       expect(subject.validate("BE1817331999")).to eql(false)
     end
 
-    it "validates a BG vat number" do
+    it "validates a BG VAT number" do
       expect(subject.validate("BG468134789")).to eql(true)
       expect(subject.validate("BG4681347897")).to eql(true)
 
@@ -37,7 +37,7 @@ describe Valvat::Syntax do
       expect(subject.validate("BG46813478")).to eql(false)
     end
 
-    it "validates a CY vat number" do
+    it "validates a CY VAT number" do
       expect(subject.validate("CY36579347A")).to eql(true)
       expect(subject.validate("CY36579347C")).to eql(true)
 
@@ -47,7 +47,7 @@ describe Valvat::Syntax do
       expect(subject.validate("CY365793G")).to eql(false)
     end
 
-    it "validates a DK vat number" do
+    it "validates a DK VAT number" do
       expect(subject.validate("DK67893463")).to eql(true)
 
       expect(subject.validate("DK678934637")).to eql(false)
@@ -55,7 +55,7 @@ describe Valvat::Syntax do
       expect(subject.validate("DK6789346H")).to eql(false)
     end
 
-    it "validates a ES vat number" do
+    it "validates a ES VAT number" do
       expect(subject.validate("ESX67345987")).to eql(true)
       expect(subject.validate("ESA6734598B")).to eql(true)
       expect(subject.validate("ES56734598C")).to eql(true)
@@ -65,14 +65,14 @@ describe Valvat::Syntax do
       expect(subject.validate("ESX673459890")).to eql(false)
     end
 
-    it "validates a EE vat number" do
+    it "validates a EE VAT number" do
       expect(subject.validate("EE100207415")).to eql(true)
       expect(subject.validate("EE1002074150")).to eql(false)
       expect(subject.validate("EE10020741")).to eql(false)
       expect(subject.validate("EE100207415K")).to eql(false)
     end
 
-    it "validates a FI vat number" do
+    it "validates a FI VAT number" do
       expect(subject.validate("FI67845638")).to eql(true)
 
       expect(subject.validate("FI678456389")).to eql(false)
@@ -80,7 +80,7 @@ describe Valvat::Syntax do
       expect(subject.validate("FI6784563K")).to eql(false)
     end
 
-    it "validates a FR vat number" do
+    it "validates a FR VAT number" do
       expect(subject.validate("FR99123543267")).to eql(true)
       expect(subject.validate("FRBB123543267")).to eql(true)
       expect(subject.validate("FR9B123543267")).to eql(true)
@@ -92,7 +92,7 @@ describe Valvat::Syntax do
       expect(subject.validate("FRB9123543")).to eql(false)
     end
 
-    it "validates a EL vat number" do
+    it "validates a EL VAT number" do
       expect(subject.validate("EL678456345")).to eql(true)
 
       expect(subject.validate("EL67845634")).to eql(false)
@@ -100,7 +100,7 @@ describe Valvat::Syntax do
       expect(subject.validate("EL67845634P")).to eql(false)
     end
 
-    it "validates a HU vat number" do
+    it "validates a HU VAT number" do
       expect(subject.validate("HU67894595")).to eql(true)
 
       expect(subject.validate("HU6789459")).to eql(false)
@@ -108,7 +108,7 @@ describe Valvat::Syntax do
       expect(subject.validate("HU6789459J")).to eql(false)
     end
 
-    it "validates a HR vat number" do
+    it "validates a HR VAT number" do
       expect(subject.validate("HR12345678912")).to eql(true)
 
       expect(subject.validate("HR6789459")).to eql(false)
@@ -116,7 +116,7 @@ describe Valvat::Syntax do
       expect(subject.validate("HR6789459J")).to eql(false)
     end
 
-    it "validates a IE vat number" do
+    it "validates a IE VAT number" do
       expect(subject.validate("IE1B12345J")).to eql(true)
       expect(subject.validate("IE1234567B")).to eql(true)
       expect(subject.validate("IE1234567XX")).to eql(true)
@@ -128,7 +128,7 @@ describe Valvat::Syntax do
       expect(subject.validate("IE1X34567XX")).to eql(false)
     end
 
-    it "validates a IT vat number" do
+    it "validates a IT VAT number" do
       expect(subject.validate("IT45875359285")).to eql(true)
 
       expect(subject.validate("IT458753592859")).to eql(false)
@@ -136,7 +136,7 @@ describe Valvat::Syntax do
       expect(subject.validate("IT4587535928")).to eql(false)
     end
 
-    it "validates a LV vat number" do
+    it "validates a LV VAT number" do
       expect(subject.validate("LV85678368906")).to eql(true)
 
       expect(subject.validate("LV8567836890")).to eql(false)
@@ -144,7 +144,7 @@ describe Valvat::Syntax do
       expect(subject.validate("LV8567836890S")).to eql(false)
     end
 
-    it "validates a LT vat number" do
+    it "validates a LT VAT number" do
       expect(subject.validate("LT213179412")).to eql(true)
       expect(subject.validate("LT290061371314")).to eql(true)
 
@@ -158,7 +158,7 @@ describe Valvat::Syntax do
       expect(subject.validate("LT290061371314H")).to eql(false)
     end
 
-    it "validates a LU vat number" do
+    it "validates a LU VAT number" do
       expect(subject.validate("LU45679456")).to eql(true)
 
       expect(subject.validate("LU4567945")).to eql(false)
@@ -166,7 +166,7 @@ describe Valvat::Syntax do
       expect(subject.validate("LU4567945J")).to eql(false)
     end
 
-    it "validates a MT vat number" do
+    it "validates a MT VAT number" do
       expect(subject.validate("MT64569367")).to eql(true)
 
       expect(subject.validate("MT6456936")).to eql(false)
@@ -174,7 +174,7 @@ describe Valvat::Syntax do
       expect(subject.validate("MT6456936L")).to eql(false)
     end
 
-    it "validates a NL vat number" do
+    it "validates a NL VAT number" do
       expect(subject.validate("NL673739491B77")).to eql(true)
 
       expect(subject.validate("NL673739491977")).to eql(false)
@@ -184,7 +184,7 @@ describe Valvat::Syntax do
       expect(subject.validate("NL6737394917B7")).to eql(false)
     end
 
-    it "validates a PL vat number" do
+    it "validates a PL VAT number" do
       expect(subject.validate("PL6784567284")).to eql(true)
 
       expect(subject.validate("PL678456728")).to eql(false)
@@ -192,14 +192,14 @@ describe Valvat::Syntax do
       expect(subject.validate("PL678456728K")).to eql(false)
     end
 
-    it "validates a PT vat number" do
+    it "validates a PT VAT number" do
       expect(subject.validate("PT346296476")).to eql(true)
 
       expect(subject.validate("PT34629647")).to eql(false)
       expect(subject.validate("PT3462964769")).to eql(false)
     end
 
-    it "validates a GB vat number" do
+    it "validates a GB VAT number" do
       expect(subject.validate("GB123456789")).to eql(true)
       expect(subject.validate("GB123456789012")).to eql(true)
       expect(subject.validate("GBGD123")).to eql(true)
@@ -216,7 +216,7 @@ describe Valvat::Syntax do
       expect(subject.validate("GBGD12")).to eql(false)
     end
 
-    it "validates a RO vat number" do
+    it "validates a RO VAT number" do
       expect(subject.validate("RO1234567890")).to eql(true)
       expect(subject.validate("RO123456789")).to eql(true)
       expect(subject.validate("RO12345678")).to eql(true)
@@ -240,21 +240,21 @@ describe Valvat::Syntax do
       expect(subject.validate("RO12345678901")).to eql(false)
     end
 
-    it "validates a SK vat number" do
+    it "validates a SK VAT number" do
       expect(subject.validate("SK5683075682")).to eql(true)
 
       expect(subject.validate("SK56830756821")).to eql(false)
       expect(subject.validate("SK568307568")).to eql(false)
     end
 
-    it "validates a SI vat number" do
+    it "validates a SI VAT number" do
       expect(subject.validate("SI74357893")).to eql(true)
 
       expect(subject.validate("SI743578931")).to eql(false)
       expect(subject.validate("SI7435789")).to eql(false)
     end
 
-    it "validates a SE vat number" do
+    it "validates a SE VAT number" do
       expect(subject.validate("SE567396352701")).to eql(true)
 
       expect(subject.validate("SE56739635201")).to eql(false)
@@ -263,7 +263,7 @@ describe Valvat::Syntax do
       expect(subject.validate("SE567396352711")).to eql(false)
     end
 
-    it "validates a CZ vat number" do
+    it "validates a CZ VAT number" do
       expect(subject.validate("CZ56389267")).to eql(true)
       expect(subject.validate("CZ563892670")).to eql(true)
       expect(subject.validate("CZ5638926790")).to eql(true)
@@ -272,7 +272,7 @@ describe Valvat::Syntax do
       expect(subject.validate("CZ56389268901")).to eql(false)
     end
 
-    it "returns false on blank/non-sense vat number" do
+    it "returns false on blank/non-sense VAT number" do
       expect(subject.validate("")).to eql(false)
       expect(subject.validate(" ")).to eql(false)
       expect(subject.validate("DE")).to eql(false)