savon 2.2.0 → 2.12.1

data/spec/savon/qualified_message_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+module Savon
+  describe QualifiedMessage, "#to_hash" do
+
+    context "if a key ends with !" do
+      let(:used_namespaces) { {} }
+      let(:key_converter) { :camelcase }
+      let(:types) { {} }
+
+      it "restores the ! in a key" do
+        message = described_class.new(types, used_namespaces, key_converter)
+        resulting_hash = message.to_hash({:Metal! => "<Nice/>"}, ["Rock"])
+
+        expect(resulting_hash).to eq({ :Metal! => "<Nice/>" })
+      end
+
+      it "properly handles special keys when namespaces are present" do
+        used_namespaces = {
+          %w(tns Foo) => 'ns',
+          %w(tns Foo Bar) => 'ns'
+        }
+
+        hash = {
+          :foo => {
+            :bar => {
+              :zing => 'pow'
+            },
+            :cash => {
+              :@attr1 => 'val1',
+              :content! => 'Chunky Bacon'
+            },
+            :attributes! => {
+              :bar => { :attr2 => 'val2' },
+            },
+            :"self_closing/" => '',
+            :order! => [:cash, :bar, :"self_closing/"]
+          }
+        }
+
+        good_result = {
+          "ns:Foo" => {
+            'ns:Bar' => { :zing => "pow" },
+            :cash => {
+              :@attr1 => "val1",
+              :content! => "Chunky Bacon"
+            },
+            :attributes! => {
+              'ns:Bar' => { :attr2 => 'val2' }
+            },
+            :"self_closing/" => '',
+            :order! => [:cash, 'ns:Bar', :"self_closing/"]
+          }
+        }
+
+        good_xml = %(<ns:Foo><Cash attr1="val1">Chunky Bacon</Cash><ns:Bar attr2="val2"><Zing>pow</Zing></ns:Bar><SelfClosing/></ns:Foo>)
+
+        message = described_class.new(types, used_namespaces, key_converter)
+        resulting_hash = message.to_hash(hash, ['tns'])
+        xml = Gyoku.xml(resulting_hash, key_converter: key_converter)
+
+        expect(resulting_hash).to eq good_result
+        expect(xml).to eq good_xml
+      end
+
+      it "properly handles boolean false" do
+        used_namespaces = {
+          %w(tns Foo) => 'ns'
+        }
+
+        hash = {
+          :foo => {
+            :falsey => {
+              :@attr1 => false,
+              :content! => false
+            }
+          }
+        }
+
+        good_result = {
+          "ns:Foo" => {
+            :falsey => {
+              :@attr1 => false,
+              :content! => false
+            }
+          }
+        }
+
+        good_xml = %(<ns:Foo><Falsey attr1="false">false</Falsey></ns:Foo>)
+
+        message = described_class.new(types, used_namespaces, key_converter)
+        resulting_hash = message.to_hash(hash, ['tns'])
+        xml = Gyoku.xml(resulting_hash, key_converter: key_converter)
+
+        expect(resulting_hash).to eq good_result
+        expect(xml).to eq good_xml
+      end
+    end
+
+  end
+end

data/spec/savon/request_logger_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Savon::RequestLogger do
+
+  subject            { described_class.new(globals) }
+  let(:globals)      { Savon::GlobalOptions.new(:log => true, :pretty_print_xml => true) }
+  let(:request) {
+    stub('Request',
+         :url     => 'http://example.com',
+         :headers => [],
+         :body    => '<TestRequest />'
+        )
+  }
+
+  let(:response) {
+    stub('Response',
+         :code => 200,
+         :body => '<TestResponse />'
+        )
+  }
+
+  before(:each) {
+    globals[:logger].level = Logger::DEBUG
+  }
+
+  describe '#log_request / #log_response' do
+    it 'does not prepare log messages when no logging is needed' do
+      begin
+        globals[:logger].level = Logger::FATAL
+
+        Savon::LogMessage.expects(:new).never
+        subject.log(request) { response }
+      end
+    end
+
+  end
+end

data/spec/savon/request_spec.rb

@@ -5,6 +5,7 @@ describe Savon::WSDLRequest do
 
   let(:globals)      { Savon::GlobalOptions.new }
   let(:http_request) { HTTPI::Request.new }
+  let(:ciphers)      { OpenSSL::Cipher.ciphers }
 
   def new_wsdl_request
     Savon::WSDLRequest.new(globals, http_request)
@@ -16,6 +17,20 @@ describe Savon::WSDLRequest do
       expect(wsdl_request.build).to be_an(HTTPI::Request)
     end
 
+    describe "headers" do
+      it "are set when specified" do
+        globals.headers("Proxy-Authorization" => "Basic auth")
+        configured_http_request = new_wsdl_request.build
+
+        expect(configured_http_request.headers["Proxy-Authorization"]).to eq("Basic auth")
+      end
+
+      it "are not set otherwise" do
+        configured_http_request = new_wsdl_request.build
+        expect(configured_http_request.headers).to_not include("Proxy-Authorization")
+      end
+    end
+
     describe "proxy" do
       it "is set when specified" do
         globals.proxy("http://proxy.example.com")
@@ -60,8 +75,8 @@ describe Savon::WSDLRequest do
 
     describe "ssl version" do
       it "is set when specified" do
-        globals.ssl_version(:SSLv3)
-        http_request.auth.ssl.expects(:ssl_version=).with(:SSLv3)
+        globals.ssl_version(:TLSv1)
+        http_request.auth.ssl.expects(:ssl_version=).with(:TLSv1)
 
         new_wsdl_request.build
       end
@@ -74,8 +89,8 @@ describe Savon::WSDLRequest do
 
     describe "ssl verify mode" do
       it "is set when specified" do
-        globals.ssl_verify_mode(:none)
-        http_request.auth.ssl.expects(:verify_mode=).with(:none)
+        globals.ssl_verify_mode(:peer)
+        http_request.auth.ssl.expects(:verify_mode=).with(:peer)
 
         new_wsdl_request.build
       end
@@ -86,6 +101,20 @@ describe Savon::WSDLRequest do
       end
     end
 
+    describe "ssl ciphers" do
+      it "is set when specified" do
+        globals.ssl_ciphers(ciphers)
+        http_request.auth.ssl.expects(:ciphers=).with(ciphers)
+
+        new_wsdl_request.build
+      end
+
+      it "is not set otherwise" do
+        http_request.auth.ssl.expects(:ciphers=).never
+        new_wsdl_request.build
+      end
+    end
+
     describe "ssl cert key file" do
       it "is set when specified" do
         cert_key = File.expand_path("../../fixtures/ssl/client_key.pem", __FILE__)
@@ -129,12 +158,15 @@ describe Savon::WSDLRequest do
 
           new_wsdl_request.build
 
-          expect { http_request.auth.ssl.cert_key }.to raise_error(OpenSSL::PKey::RSAError)
+          expect { http_request.auth.ssl.cert_key }.to raise_error
         end
       end
 
       describe "set with a valid decrypting password" do
         it "handles SSL private keys properly" do
+          if RUBY_ENGINE == 'jruby'
+            pending("find out why this fails with a null pointer exception on jruby")
+          end
           pass = "secure-password!42"
           key  = File.expand_path("../../fixtures/ssl/client_encrypted_key.pem", __FILE__)
           cert = File.expand_path("../../fixtures/ssl/client_encrypted_key_cert.pem", __FILE__)
@@ -145,7 +177,7 @@ describe Savon::WSDLRequest do
 
           new_wsdl_request.build
 
-          http_request.auth.ssl.cert_key.to_s.should =~ /BEGIN RSA PRIVATE KEY/
+          expect(http_request.auth.ssl.cert_key.to_s).to match(/BEGIN RSA PRIVATE KEY/)
         end
       end
     end
@@ -207,6 +239,20 @@ describe Savon::WSDLRequest do
         new_wsdl_request.build
       end
     end
+
+    describe "ntlm auth" do
+      it "is set when specified" do
+        globals.ntlm("han", "super-secret")
+        http_request.auth.expects(:ntlm).with("han", "super-secret")
+
+        new_wsdl_request.build
+      end
+
+      it "is not set otherwise" do
+        http_request.auth.expects(:ntlm).never
+        new_wsdl_request.build
+      end
+    end
   end
 
 end
@@ -215,6 +261,7 @@ describe Savon::SOAPRequest do
 
   let(:globals)      { Savon::GlobalOptions.new }
   let(:http_request) { HTTPI::Request.new }
+  let(:ciphers)      { OpenSSL::Cipher.ciphers }
 
   def new_soap_request
     Savon::SOAPRequest.new(globals, http_request)
@@ -347,8 +394,8 @@ describe Savon::SOAPRequest do
 
     describe "ssl version" do
       it "is set when specified" do
-        globals.ssl_version(:SSLv3)
-        http_request.auth.ssl.expects(:ssl_version=).with(:SSLv3)
+        globals.ssl_version(:TLSv1)
+        http_request.auth.ssl.expects(:ssl_version=).with(:TLSv1)
 
         new_soap_request.build
       end
@@ -361,8 +408,8 @@ describe Savon::SOAPRequest do
 
     describe "ssl verify mode" do
       it "is set when specified" do
-        globals.ssl_verify_mode(:none)
-        http_request.auth.ssl.expects(:verify_mode=).with(:none)
+        globals.ssl_verify_mode(:peer)
+        http_request.auth.ssl.expects(:verify_mode=).with(:peer)
 
         new_soap_request.build
       end
@@ -373,6 +420,20 @@ describe Savon::SOAPRequest do
       end
     end
 
+    describe "ssl ciphers" do
+      it "is set when specified" do
+        globals.ssl_ciphers(ciphers)
+        http_request.auth.ssl.expects(:ciphers=).with(ciphers)
+
+        new_soap_request.build
+      end
+
+      it "is not set otherwise" do
+        http_request.auth.ssl.expects(:ciphers=).never
+        new_soap_request.build
+      end
+    end
+
     describe "ssl cert key file" do
       it "is set when specified" do
         cert_key = File.expand_path("../../fixtures/ssl/client_key.pem", __FILE__)
@@ -460,6 +521,20 @@ describe Savon::SOAPRequest do
         new_soap_request.build
       end
     end
+
+    describe "ntlm auth" do
+      it "is set when specified" do
+        globals.ntlm("han", "super-secret")
+        http_request.auth.expects(:ntlm).with("han", "super-secret")
+
+        new_soap_request.build
+      end
+
+      it "is not set otherwise" do
+        http_request.auth.expects(:ntlm).never
+        new_soap_request.build
+      end
+    end
   end
 
 end

data/spec/savon/response_spec.rb

@@ -7,16 +7,16 @@ describe Savon::Response do
 
   describe ".new" do
     it "should raise a Savon::Fault in case of a SOAP fault" do
-      lambda { soap_fault_response }.should raise_error(Savon::SOAPFault)
+      expect { soap_fault_response }.to raise_error(Savon::SOAPFault)
     end
 
     it "should not raise a Savon::Fault in case the default is turned off" do
       globals[:raise_errors] = false
-      lambda { soap_fault_response }.should_not raise_error(Savon::SOAPFault)
+      expect { soap_fault_response }.not_to raise_error
     end
 
     it "should raise a Savon::HTTP::Error in case of an HTTP error" do
-      lambda { soap_response :code => 500 }.should raise_error(Savon::HTTPError)
+      expect { soap_response :code => 500 }.to raise_error(Savon::HTTPError)
     end
 
     it "should not raise a Savon::HTTP::Error in case the default is turned off" do
@@ -29,15 +29,15 @@ describe Savon::Response do
     before { globals[:raise_errors] = false }
 
     it "should return true if the request was successful" do
-      soap_response.should be_a_success
+      expect(soap_response).to be_a_success
     end
 
     it "should return false if there was a SOAP fault" do
-      soap_fault_response.should_not be_a_success
+      expect(soap_fault_response).not_to be_a_success
     end
 
     it "should return false if there was an HTTP error" do
-      http_error_response.should_not be_a_success
+      expect(http_error_response).not_to be_a_success
     end
   end
 
@@ -45,11 +45,23 @@ describe Savon::Response do
     before { globals[:raise_errors] = false }
 
     it "should not return true in case the response seems to be ok" do
-      soap_response.soap_fault?.should be_false
+      expect(soap_response.soap_fault?).to be_falsey
     end
 
     it "should return true in case of a SOAP fault" do
-      soap_fault_response.soap_fault?.should be_true
+      expect(soap_fault_response.soap_fault?).to be_truthy
+    end
+  end
+
+  describe "#soap_fault" do
+    before { globals[:raise_errors] = false }
+
+    it "should return nil in case the response seems to be ok" do
+      expect(soap_response.soap_fault).to be_nil
+    end
+
+    it "should return a SOAPFault in case of a SOAP fault" do
+      expect(soap_fault_response.soap_fault).to be_a(Savon::SOAPFault)
     end
   end
 
@@ -57,44 +69,108 @@ describe Savon::Response do
     before { globals[:raise_errors] = false }
 
     it "should not return true in case the response seems to be ok" do
-      soap_response.http_error?.should_not be_true
+      expect(soap_response.http_error?).not_to be_truthy
     end
 
     it "should return true in case of an HTTP error" do
-      soap_response(:code => 500).http_error?.should be_true
+      expect(soap_response(:code => 500).http_error?).to be_truthy
+    end
+  end
+
+  describe "#http_error" do
+    before { globals[:raise_errors] = false }
+
+    it "should return nil in case the response seems to be ok" do
+      expect(soap_response.http_error).to be_nil
+    end
+
+    it "should return a HTTPError in case of an HTTP error" do
+      expect(soap_response(:code => 500).http_error).to be_a(Savon::HTTPError)
     end
   end
 
   describe "#header" do
     it "should return the SOAP response header as a Hash" do
       response = soap_response :body => Fixture.response(:header)
-      response.header.should include(:session_number => "ABCD1234")
+      expect(response.header).to include(:session_number => "ABCD1234")
+    end
+
+    it 'respects the global :strip_namespaces option' do
+      globals[:strip_namespaces] = false
+
+      response_with_header = soap_response(:body => Fixture.response(:header))
+      header = response_with_header.header
+
+      expect(header).to be_a(Hash)
+
+      # notice: :session_number is a snake_case Symbol without namespaces,
+      # but the Envelope and Header elements are qualified.
+      expect(header.keys).to include(:session_number)
+    end
+
+    it 'respects the global :convert_response_tags_to option' do
+      globals[:convert_response_tags_to] = lambda { |key| key.upcase }
+
+      response_with_header = soap_response(:body => Fixture.response(:header))
+      header = response_with_header.header
+
+      expect(header).to be_a(Hash)
+      expect(header.keys).to include('SESSIONNUMBER')
+    end
+
+    it 'respects the global :convert_attributes_to option' do
+      globals[:convert_attributes_to] = lambda { |k,v| [] }
+
+      response_with_header = soap_response(:body => Fixture.response(:header))
+      header = response_with_header.header
+
+      expect(header).to be_a(Hash)
+      expect(header.keys).to include(:session_number)
     end
 
     it "should throw an exception when the response header isn't parsable" do
-      lambda { invalid_soap_response.header }.should raise_error Savon::InvalidResponseError
+      expect { invalid_soap_response.header }.to raise_error Savon::InvalidResponseError
     end
   end
 
   %w(body to_hash).each do |method|
     describe "##{method}" do
       it "should return the SOAP response body as a Hash" do
-        soap_response.send(method)[:authenticate_response][:return].should ==
+        expect(soap_response.send(method)[:authenticate_response][:return]).to eq(
           Fixture.response_hash(:authentication)[:authenticate_response][:return]
+        )
       end
 
       it "should return a Hash for a SOAP multiRef response" do
         hash = soap_response(:body => Fixture.response(:multi_ref)).send(method)
 
-        hash[:list_response].should be_a(Hash)
-        hash[:multi_ref].should be_an(Array)
+        expect(hash[:list_response]).to be_a(Hash)
+        expect(hash[:multi_ref]).to be_an(Array)
       end
 
       it "should add existing namespaced elements as an array" do
         hash = soap_response(:body => Fixture.response(:list)).send(method)
 
-        hash[:multi_namespaced_entry_response][:history].should be_a(Hash)
-        hash[:multi_namespaced_entry_response][:history][:case].should be_an(Array)
+        expect(hash[:multi_namespaced_entry_response][:history]).to be_a(Hash)
+        expect(hash[:multi_namespaced_entry_response][:history][:case]).to be_an(Array)
+      end
+
+      it 'respects the global :strip_namespaces option' do
+        globals[:strip_namespaces] = false
+
+        body = soap_response.body
+
+        expect(body).to be_a(Hash)
+        expect(body.keys).to include(:"ns2:authenticate_response")
+      end
+
+      it 'respects the global :convert_response_tags_to option' do
+        globals[:convert_response_tags_to] = lambda { |key| key.upcase }
+
+        body = soap_response.body
+
+        expect(body).to be_a(Hash)
+        expect(body.keys).to include('AUTHENTICATERESPONSE')
       end
     end
   end
@@ -102,25 +178,26 @@ describe Savon::Response do
   describe "#to_array" do
     context "when the given path exists" do
       it "should return an Array containing the path value" do
-        soap_response.to_array(:authenticate_response, :return).should ==
+        expect(soap_response.to_array(:authenticate_response, :return)).to eq(
           [Fixture.response_hash(:authentication)[:authenticate_response][:return]]
+        )
       end
 
       it "should properly return FalseClass values [#327]" do
         body = Gyoku.xml(:envelope => { :body => { :return => { :success => false } } })
-        soap_response(:body => body).to_array(:return, :success).should == [false]
+        expect(soap_response(:body => body).to_array(:return, :success)).to eq([false])
       end
     end
 
     context "when the given path returns nil" do
       it "should return an empty Array" do
-        soap_response.to_array(:authenticate_response, :undefined).should == []
+        expect(soap_response.to_array(:authenticate_response, :undefined)).to eq([])
       end
     end
 
     context "when the given path does not exist at all" do
       it "should return an empty Array" do
-        soap_response.to_array(:authenticate_response, :some, :undefined, :path).should == []
+        expect(soap_response.to_array(:authenticate_response, :some, :undefined, :path)).to eq([])
       end
     end
   end
@@ -128,32 +205,46 @@ describe Savon::Response do
   describe "#hash" do
     it "should return the complete SOAP response XML as a Hash" do
       response = soap_response :body => Fixture.response(:header)
-      response.hash[:envelope][:header][:session_number].should == "ABCD1234"
+      expect(response.hash[:envelope][:header][:session_number]).to eq("ABCD1234")
     end
   end
 
   describe "#to_xml" do
     it "should return the raw SOAP response body" do
-      soap_response.to_xml.should == Fixture.response(:authentication)
+      expect(soap_response.to_xml).to eq(Fixture.response(:authentication))
     end
   end
 
   describe "#doc" do
     it "returns a Nokogiri::XML::Document for the SOAP response XML" do
-      soap_response.doc.should be_a(Nokogiri::XML::Document)
+      expect(soap_response.doc).to be_a(Nokogiri::XML::Document)
     end
   end
 
   describe "#xpath" do
     it "permits XPath access to elements in the request" do
-      soap_response.xpath("//client").first.inner_text.should == "radclient"
-      soap_response.xpath("//ns2:authenticateResponse/return/success").first.inner_text.should == "true"
+      expect(soap_response.xpath("//client").first.inner_text).to eq("radclient")
+      expect(soap_response.xpath("//ns2:authenticateResponse/return/success").first.inner_text).to eq("true")
+    end
+  end
+
+  describe '#find' do
+    it 'delegates to Nori#find to find child elements inside the Envelope' do
+      result = soap_response.find('Body', 'authenticateResponse', 'return')
+
+      expect(result).to be_a(Hash)
+      expect(result.keys).to include(:authentication_value)
+    end
+
+    it 'fails correctly when envelope contains only string' do
+      response = soap_response({ :body => Fixture.response(:no_body) })
+      expect { response.find('Body') }.to raise_error Savon::InvalidResponseError
     end
   end
 
   describe "#http" do
     it "should return the HTTPI::Response" do
-      soap_response.http.should be_an(HTTPI::Response)
+      expect(soap_response.http).to be_an(HTTPI::Response)
     end
   end