savon 1.2.0 → 2.0.0

data/spec/savon/observers_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe Savon do
+
+  before :all do
+    @server = IntegrationServer.run
+  end
+
+  after :all do
+    @server.stop
+  end
+
+  describe ".observers" do
+    after :each do
+      Savon.observers.clear
+    end
+
+    it "allows to register an observer for every request" do
+      observer = Class.new {
+
+        def notify(operation_name, builder, globals, locals)
+          @operation_name = operation_name
+
+          @builder = builder
+          @globals = globals
+          @locals  = locals
+
+          # return nil to execute the request
+          nil
+        end
+
+        attr_reader :operation_name, :builder, :globals, :locals
+
+      }.new
+
+      Savon.observers << observer
+
+      new_client.call(:authenticate)
+
+      expect(observer.operation_name).to eq(:authenticate)
+
+      expect(observer.builder).to be_a(Savon::Builder)
+      expect(observer.globals).to be_a(Savon::GlobalOptions)
+      expect(observer.locals).to  be_a(Savon::LocalOptions)
+    end
+
+    it "allows to register an observer which mocks requests" do
+      observer = Class.new {
+
+        def notify(*)
+          # return a response to mock the request
+          HTTPI::Response.new(201, { "X-Result" => "valid" }, "valid!")
+        end
+
+      }.new
+
+      Savon.observers << observer
+
+      response = new_client.call(:authenticate)
+
+      expect(response.http.code).to eq(201)
+      expect(response.http.headers).to eq("X-Result" => "valid")
+      expect(response.http.body).to eq("valid!")
+    end
+
+    it "raises if an observer returns something other than nil or an HTTPI::Response" do
+      observer = Class.new {
+
+        def notify(*)
+          []
+        end
+
+      }.new
+
+      Savon.observers << observer
+
+      expect { new_client.call(:authenticate) }.
+        to raise_error(Savon::Error, "Observers need to return an HTTPI::Response " \
+                                     "to mock the request or nil to execute the request.")
+    end
+  end
+
+  def new_client
+    Savon.client(
+      :endpoint  => @server.url(:repeat),
+      :namespace => "http://v1.example.com",
+      :log       => false
+    )
+  end
+
+end

data/spec/savon/operation_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe Savon::Operation do
+
+  let(:globals) { Savon::GlobalOptions.new(:endpoint => @server.url(:repeat), :log => false) }
+  let(:wsdl)    { Wasabi::Document.new Fixture.wsdl(:authentication) }
+  let(:no_wsdl) { Wasabi::Document.new }
+
+  before :all do
+    @server = IntegrationServer.run
+  end
+
+  after :all do
+    @server.stop
+  end
+
+  describe ".create with a WSDL" do
+    it "returns a new operation" do
+      operation = Savon::Operation.create(:authenticate, wsdl, globals)
+      expect(operation).to be_a(Savon::Operation)
+    end
+
+    it "raises if the operation name is not a Symbol" do
+      expect { Savon::Operation.create("not a symbol", wsdl, globals) }.
+        to raise_error(ArgumentError, /Expected the first parameter \(the name of the operation to call\) to be a symbol/)
+    end
+
+    it "raises if the operation is not available for the service" do
+      expect { Savon::Operation.create(:no_such_operation, wsdl, globals) }.
+        to raise_error(ArgumentError, /Unable to find SOAP operation: :no_such_operation/)
+    end
+  end
+
+  describe ".create without a WSDL" do
+    it "returns a new operation" do
+      operation = Savon::Operation.create(:authenticate, no_wsdl, globals)
+      expect(operation).to be_a(Savon::Operation)
+    end
+  end
+
+  describe "#call" do
+    it "returns a response object" do
+      operation = Savon::Operation.create(:authenticate, wsdl, globals)
+      expect(operation.call).to be_a(Savon::Response)
+    end
+  end
+
+end

data/spec/savon/request_spec.rb

@@ -0,0 +1,145 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe Savon::Request do
+
+  subject(:request) { Savon::Request.new(:authenticate, wsdl, globals, locals) }
+
+  let(:globals)     { Savon::GlobalOptions.new(:endpoint => @server.url, :log => false) }
+  let(:locals)      { Savon::LocalOptions.new }
+  let(:wsdl)        { Wasabi::Document.new Fixture.wsdl(:authentication) }
+  let(:no_wsdl)     { Wasabi::Document.new }
+
+  before :all do
+    @server = IntegrationServer.run
+  end
+
+  after :all do
+    @server.stop
+  end
+
+  describe "#call" do
+    it "expects the XML to POST" do
+      response = request.call("<xml/>")
+
+      expect(request.http.url).to eq(URI(globals[:endpoint]))
+      expect(request.http.body).to eq("<xml/>")
+      expect(request.http.headers["Content-Length"]).to eq("<xml/>".bytesize.to_s)
+
+      expect(response).to be_a(HTTPI::Response)
+    end
+
+    it "falls back to use the WSDL's endpoint if the global :endpoint option was not set" do
+      wsdl.endpoint = @server.url
+      globals_without_endpoint = Savon::GlobalOptions.new(:log => false)
+      request = Savon::Request.new(:authenticate, wsdl, globals_without_endpoint, locals)
+      response = request.call("<xml/>")
+
+      expect(request.http.url).to eq(URI(wsdl.endpoint))
+    end
+
+    it "sets the global :proxy option if it's available" do
+      globals[:proxy] = "http://proxy.example.com"
+      expect(request.http.proxy).to eq(URI(globals[:proxy]))
+    end
+
+    it "does not set the global :proxy option when it's not available" do
+      expect(request.http.proxy).to be_nil
+    end
+
+    it "sets the request cookies using the global :last_response option if it's available" do
+      http = HTTPI::Response.new(200, {}, ["<success/>"])
+      globals[:last_response] = Savon::Response.new(http, globals, locals)
+
+      HTTPI::Request.any_instance.expects(:set_cookies).with(globals[:last_response]).once
+      request
+    end
+
+    it "does not set the cookies using the global :last_response option when it's not available" do
+      expect(request.http.open_timeout).to be_nil
+    end
+
+    it "sets the global :open_timeout option if it's available" do
+      globals[:open_timeout] = 33
+      expect(request.http.open_timeout).to eq(globals[:open_timeout])
+    end
+
+    it "does not set the global :open_timeout option when it's not available" do
+      request.call("<xml/>")
+      expect(request.http.open_timeout).to be_nil
+    end
+
+    it "sets the global :read_timeout option if it's available" do
+      globals[:read_timeout] = 44
+      expect(request.http.read_timeout).to eq(globals[:read_timeout])
+    end
+
+    it "does not set the global :read_timeout option when it's not available" do
+      expect(request.http.read_timeout).to be_nil
+    end
+
+    it "sets the global :headers option if it's available" do
+      globals[:headers] = { "X-Authorize" => "secret" }
+      expect(request.http.headers["X-Authorize"]).to eq("secret")
+    end
+
+    it "sets the SOAPAction header using the local :soap_action option if it's available" do
+      locals[:soap_action] = "urn://authenticate"
+      expect(request.http.headers["SOAPAction"]).to eq(%{"#{locals[:soap_action]}"})
+    end
+
+    it "sets the SOAPAction header using the WSDL if it's available" do
+      expect(request.http.headers["SOAPAction"]).to eq(%{"authenticate"})
+    end
+
+    it "sets the SOAPAction header using Gyoku if both option and WSDL were not set" do
+      request = Savon::Request.new(:authenticate, no_wsdl, globals, locals)
+      expect(request.http.headers["SOAPAction"]).to eq(%{"authenticate"})
+    end
+
+    it "does not set the SOAPAction header if it's already set" do
+      locals[:soap_action] = "urn://authenticate"
+      globals[:headers] = { "SOAPAction" => %{"doAuthenticate"} }
+
+      expect(request.http.headers["SOAPAction"]).to eq(%{"doAuthenticate"})
+    end
+
+    it "does not set the SOAPAction header if the local :soap_action was set to nil" do
+      locals[:soap_action] = nil
+      expect(request.http.headers).to_not include("SOAPAction")
+    end
+
+    it "sets the SOAP 1.2 Content-Type header using the global :soap_version and :encoding options if available" do
+      globals[:soap_version] = 2
+      globals[:encoding] = "UTF-16"
+
+      expect(request.http.headers["Content-Type"]).to eq("application/soap+xml;charset=UTF-16")
+    end
+
+    it "sets the SOAP 1.1 Content-Type header using the global :soap_version and :encoding options if available" do
+      globals[:soap_version] = 1
+      globals[:encoding] = "UTF-8"
+
+      expect(request.http.headers["Content-Type"]).to eq("text/xml;charset=UTF-8")
+    end
+
+    it "sets the global :basic_auth option if it's available" do
+      globals[:basic_auth] = [:luke, "secret"]
+      expect(request.http.auth.basic).to eq(globals[:basic_auth])
+    end
+
+    it "does not set the global :basic_auth option when it's not available" do
+      expect(request.http.auth.basic).to be_nil
+    end
+
+    it "sets the global :digest_auth option if it's available" do
+      globals[:digest_auth] = [:lea, "top-secret"]
+      expect(request.http.auth.digest).to eq(globals[:digest_auth])
+    end
+
+    it "does not set the global :digest_auth option when it's not available" do
+      expect(request.http.auth.digest).to be_nil
+    end
+  end
+
+end

data/spec/savon/{soap/response_spec.rb → response_spec.rb}

@@ -1,31 +1,32 @@
 require "spec_helper"
 
-describe Savon::SOAP::Response do
+describe Savon::Response do
 
-  let(:config) { Savon::Config.default }
+  let(:globals) { Savon::GlobalOptions.new }
+  let(:locals)  { Savon::LocalOptions.new }
 
   describe ".new" do
-    it "should raise a Savon::SOAP::Fault in case of a SOAP fault" do
-      lambda { soap_fault_response }.should raise_error(Savon::SOAP::Fault)
+    it "should raise a Savon::Fault in case of a SOAP fault" do
+      lambda { soap_fault_response }.should raise_error(Savon::SOAPFault)
     end
 
-    it "should not raise a Savon::SOAP::Fault in case the default is turned off" do
-      config.raise_errors = false
-      lambda { soap_fault_response }.should_not raise_error(Savon::SOAP::Fault)
+    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)
     end
 
     it "should raise a Savon::HTTP::Error in case of an HTTP error" do
-      lambda { soap_response :code => 500 }.should raise_error(Savon::HTTP::Error)
+      lambda { soap_response :code => 500 }.should raise_error(Savon::HTTPError)
     end
 
     it "should not raise a Savon::HTTP::Error in case the default is turned off" do
-      config.raise_errors = false
+      globals[:raise_errors] = false
       soap_response :code => 500
     end
   end
 
   describe "#success?" do
-    before { config.raise_errors = false }
+    before { globals[:raise_errors] = false }
 
     it "should return true if the request was successful" do
       soap_response.should be_a_success
@@ -41,7 +42,7 @@ describe Savon::SOAP::Response do
   end
 
   describe "#soap_fault?" do
-    before { config.raise_errors = false }
+    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
@@ -52,24 +53,8 @@ describe Savon::SOAP::Response do
     end
   end
 
-  describe "#soap_fault" do
-    before { config.raise_errors = false }
-
-    it "should return a Savon::SOAP::Fault" do
-      soap_fault_response.soap_fault.should be_a(Savon::SOAP::Fault)
-    end
-
-    it "should return a Savon::SOAP::Fault containing the HTTPI::Response" do
-      soap_fault_response.soap_fault.http.should be_an(HTTPI::Response)
-    end
-
-    it "should return a Savon::SOAP::Fault even if the SOAP response seems to be ok" do
-      soap_response.soap_fault.should be_a(Savon::SOAP::Fault)
-    end
-  end
-
   describe "#http_error?" do
-    before { config.raise_errors = false }
+    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
@@ -80,33 +65,6 @@ describe Savon::SOAP::Response do
     end
   end
 
-  describe "#http_error" do
-    before { config.raise_errors = false }
-
-    it "should return a Savon::HTTP::Error" do
-      http_error_response.http_error.should be_a(Savon::HTTP::Error)
-    end
-
-    it "should return a Savon::HTTP::Error containing the HTTPI::Response" do
-      http_error_response.http_error.http.should be_an(HTTPI::Response)
-    end
-
-    it "should return a Savon::HTTP::Error even if the HTTP response seems to be ok" do
-      soap_response.http_error.should be_a(Savon::HTTP::Error)
-    end
-  end
-
-  describe "#[]" do
-    it "should return the SOAP response body as a Hash" do
-      soap_response[:authenticate_response][:return].should ==
-        Fixture.response_hash(:authentication)[:authenticate_response][:return]
-    end
-
-    it "should throw an exception when the response body isn't parsable" do
-      lambda { invalid_soap_response.body }.should raise_error Savon::SOAP::InvalidResponseError
-    end
-  end
-
   describe "#header" do
     it "should return the SOAP response header as a Hash" do
       response = soap_response :body => Fixture.response(:header)
@@ -114,7 +72,7 @@ describe Savon::SOAP::Response do
     end
 
     it "should throw an exception when the response header isn't parsable" do
-      lambda { invalid_soap_response.header }.should raise_error Savon::SOAP::InvalidResponseError
+      lambda { invalid_soap_response.header }.should raise_error Savon::InvalidResponseError
     end
   end
 
@@ -147,6 +105,11 @@ describe Savon::SOAP::Response do
         soap_response.to_array(:authenticate_response, :return).should ==
           [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]
+      end
     end
 
     context "when the given path returns nil" do
@@ -199,7 +162,7 @@ describe Savon::SOAP::Response do
     response = defaults.merge options
     http_response = HTTPI::Response.new(response[:code], response[:headers], response[:body])
 
-    Savon::SOAP::Response.new(config, http_response)
+    Savon::Response.new(http_response, globals, locals)
   end
 
   def soap_fault_response
@@ -210,12 +173,12 @@ describe Savon::SOAP::Response do
     soap_response :code => 404, :body => "Not found"
   end
 
-  def invalid_soap_response(options={})
+  def invalid_soap_response(options = {})
     defaults = { :code => 200, :headers => {}, :body => "I'm not SOAP" }
     response = defaults.merge options
     http_response = HTTPI::Response.new(response[:code], response[:headers], response[:body])
 
-    Savon::SOAP::Response.new(config, http_response)
+    Savon::Response.new(http_response, globals, locals)
   end
 
 end

data/spec/savon/soap_fault_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+describe Savon::SOAPFault do
+  let(:soap_fault) { Savon::SOAPFault.new new_response(:body => Fixture.response(:soap_fault)), nori }
+  let(:soap_fault2) { Savon::SOAPFault.new new_response(:body => Fixture.response(:soap_fault12)), nori }
+  let(:another_soap_fault) { Savon::SOAPFault.new new_response(:body => Fixture.response(:another_soap_fault)), nori }
+  let(:no_fault) { Savon::SOAPFault.new new_response, nori }
+
+  let(:nori) { Nori.new(:strip_namespaces => true, :convert_tags_to => lambda { |tag| tag.snakecase.to_sym }) }
+
+  it "inherits from Savon::Error" do
+    expect(Savon::SOAPFault.ancestors).to include(Savon::Error)
+  end
+
+  describe "#http" do
+    it "returns the HTTPI::Response" do
+      expect(soap_fault.http).to be_an(HTTPI::Response)
+    end
+  end
+
+  describe ".present?" do
+    it "returns true if the HTTP response contains a SOAP 1.1 fault" do
+      http = new_response(:body => Fixture.response(:soap_fault))
+      expect(Savon::SOAPFault.present? http).to be_true
+    end
+
+    it "returns true if the HTTP response contains a SOAP 1.2 fault" do
+      http = new_response(:body => Fixture.response(:soap_fault12))
+      expect(Savon::SOAPFault.present? http).to be_true
+    end
+
+    it "returns true if the HTTP response contains a SOAP fault with different namespaces" do
+      http = new_response(:body => Fixture.response(:another_soap_fault))
+      expect(Savon::SOAPFault.present? http).to be_true
+    end
+
+    it "returns false unless the HTTP response contains a SOAP fault" do
+      expect(Savon::SOAPFault.present? new_response).to be_false
+    end
+  end
+
+  [:message, :to_s].each do |method|
+    describe "##{method}" do
+      it "returns a SOAP 1.1 fault message" do
+        expect(soap_fault.send method).to eq("(soap:Server) Fault occurred while processing.")
+      end
+
+      it "returns a SOAP 1.2 fault message" do
+        expect(soap_fault2.send method).to eq("(soap:Sender) Sender Timeout")
+      end
+
+      it "returns a SOAP fault message (with different namespaces)" do
+        expect(another_soap_fault.send method).to eq("(ERR_NO_SESSION) Wrong session message")
+      end
+    end
+  end
+
+  describe "#to_hash" do
+    it "returns the SOAP response as a Hash unless a SOAP fault is present" do
+      expect(no_fault.to_hash[:authenticate_response][:return][:success]).to be_true
+    end
+
+    it "returns a SOAP 1.1 fault as a Hash" do
+      expected = {
+        :fault => {
+          :faultstring => "Fault occurred while processing.",
+          :faultcode   => "soap:Server"
+        }
+      }
+
+      expect(soap_fault.to_hash).to eq(expected)
+    end
+
+    it "returns a SOAP 1.2 fault as a Hash" do
+      expected = {
+        :fault => {
+          :detail => { :max_time => "P5M" },
+          :reason => { :text => "Sender Timeout" },
+          :code   => { :value => "soap:Sender", :subcode => { :value => "m:MessageTimeout" } }
+        }
+      }
+
+      expect(soap_fault2.to_hash).to eq(expected)
+    end
+  end
+
+  def new_response(options = {})
+    defaults = { :code => 500, :headers => {}, :body => Fixture.response(:authentication) }
+    response = defaults.merge options
+
+    HTTPI::Response.new response[:code], response[:headers], response[:body]
+  end
+
+end