savon-ng-1.6 2.4.0

data/spec/savon/mock_spec.rb

@@ -0,0 +1,157 @@
+require "spec_helper"
+require "savon/mock/spec_helper"
+
+describe "Savon's mock interface" do
+  include Savon::SpecHelper
+
+  before :all do
+    savon.mock!
+  end
+
+  after :all do
+    savon.unmock!
+  end
+
+  it "can verify a request and return a fixture response" do
+    message = { :username => "luke", :password => "secret" }
+    savon.expects(:authenticate).with(:message => message).returns("<fixture/>")
+
+    response = new_client.call(:authenticate) do
+      message(:username => "luke", :password => "secret")
+    end
+
+    expect(response.http.body).to eq("<fixture/>")
+  end
+
+  it "accepts a Hash to specify the response code, headers and body" do
+    soap_fault = Fixture.response(:soap_fault)
+    response = { :code => 500, :headers => { "X-Result" => "invalid" }, :body => soap_fault }
+
+    savon.expects(:authenticate).returns(response)
+    response = new_client(:raise_errors => false).call(:authenticate)
+
+    expect(response).to_not be_successful
+    expect(response).to be_a_soap_fault
+
+    expect(response.http.code).to eq(500)
+    expect(response.http.headers).to eq("X-Result" => "invalid")
+    expect(response.http.body).to eq(soap_fault)
+  end
+
+  it "works with multiple requests" do
+    authentication_message = { :username => "luke", :password => "secret" }
+    savon.expects(:authenticate).with(:message => authentication_message).returns("")
+
+    find_user_message = { :by_username => "lea" }
+    savon.expects(:find_user).with(:message => find_user_message).returns("")
+
+    new_client.call(:authenticate, :message => authentication_message)
+    new_client.call(:find_user, :message => find_user_message)
+  end
+
+  it "fails when the expected operation was not called" do
+    # TODO: find out how to test this! [dh, 2012-12-17]
+    #savon.expects(:authenticate)
+  end
+
+  it "fails when the return value for an expectation was not specified" do
+    savon.expects(:authenticate)
+
+    expect { new_client.call(:authenticate) }.
+      to raise_error(Savon::ExpectationError, "This expectation was not set up with a response.")
+  end
+
+  it "fails with an unexpected request" do
+    expect { new_client.call(:authenticate) }.
+      to raise_error(Savon::ExpectationError, "Unexpected request to the :authenticate operation.")
+  end
+
+  it "fails with multiple requests" do
+    authentication_message = { :username => "luke", :password => "secret" }
+    savon.expects(:authenticate).with(:message => authentication_message).returns("")
+
+    create_user_message = { :username => "lea" }
+    savon.expects(:create_user).with(:message => create_user_message).returns("")
+
+    find_user_message = { :by_username => "lea" }
+    savon.expects(:find_user).with(:message => find_user_message).returns("")
+
+    # reversed order from previous spec
+    new_client.call(:authenticate, :message => authentication_message)
+
+    expect { new_client.call(:find_user, :message => find_user_message) }.
+      to raise_error(Savon::ExpectationError, "Expected a request to the :create_user operation.\n" \
+                                              "Received a request to the :find_user operation instead.")
+  end
+
+  it "fails when the expected SOAP operation does not match the actual one" do
+    savon.expects(:logout).returns("<fixture/>")
+
+    expect { new_client.call(:authenticate) }.
+      to raise_error(Savon::ExpectationError, "Expected a request to the :logout operation.\n" \
+                                              "Received a request to the :authenticate operation instead.")
+  end
+
+  it "fails when there is no actual message to match" do
+    message = { :username => "luke" }
+    savon.expects(:find_user).with(:message => message).returns("<fixture/>")
+
+    expect { new_client.call(:find_user) }.
+      to raise_error(Savon::ExpectationError, "Expected a request to the :find_user operation\n" \
+                                              "  with this message: #{message.inspect}\n" \
+                                              "Received a request to the :find_user operation\n" \
+                                              "  with no message.")
+  end
+
+  it "fails when there is no expect but an actual message" do
+    savon.expects(:find_user).returns("<fixture/>")
+    message = { :username => "luke" }
+
+    expect { new_client.call(:find_user, :message => message) }.
+      to raise_error(Savon::ExpectationError, "Expected a request to the :find_user operation\n" \
+                                              "  with no message.\n" \
+                                              "Received a request to the :find_user operation\n" \
+                                              "  with this message: #{message.inspect}")
+  end
+
+  it "does not fail when any message is expected and an actual message" do
+    savon.expects(:find_user).with(:message => :any).returns("<fixture/>")
+    message = { :username => "luke" }
+
+    expect { new_client.call(:find_user, :message => message) }.to_not raise_error
+  end
+
+  it "does not fail when any message is expected and no actual message" do
+    savon.expects(:find_user).with(:message => :any).returns("<fixture/>")
+
+    expect { new_client.call(:find_user) }.to_not raise_error
+  end
+
+
+  it "allows code to rescue Savon::Error and still report test failures" do
+    message = { :username => "luke" }
+    savon.expects(:find_user).with(:message => message).returns("<fixture/>")
+
+    expect {
+      begin
+        new_client.call(:find_user)
+      rescue Savon::Error => e
+        puts "any real error (e.g. SOAP fault or HTTP error) is OK in the big picture, move on"
+      end
+    }.to raise_error(Savon::ExpectationError, "Expected a request to the :find_user operation\n" \
+                                              "  with this message: #{message.inspect}\n" \
+                                              "Received a request to the :find_user operation\n" \
+                                              "  with no message.")
+  end
+
+  def new_client(globals = {})
+    defaults = {
+      :endpoint  => "http://example.com",
+      :namespace => "http://v1.example.com",
+      :log       => false
+    }
+
+    Savon.client defaults.merge(globals)
+  end
+
+end

data/spec/savon/model_spec.rb

@@ -0,0 +1,154 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe Savon::Model do
+
+  before :all do
+    @server = IntegrationServer.run
+  end
+
+  after :all do
+    @server.stop
+  end
+
+  describe ".client" do
+    it "returns the memoized client" do
+      model = Class.new {
+        extend Savon::Model
+        client :wsdl => Fixture.wsdl(:authentication)
+      }
+
+      expect(model.client).to be_a(Savon::Client)
+      expect(model.client).to equal(model.client)
+    end
+
+    it "raises if the client was not initialized properly" do
+      model = Class.new { extend Savon::Model }
+
+      expect { model.client }.
+        to raise_error(Savon::InitializationError, /^Expected the model to be initialized/)
+    end
+  end
+
+  describe ".global" do
+    it "sets global options" do
+      model = Class.new {
+        extend Savon::Model
+
+        client :wsdl => Fixture.wsdl(:authentication)
+
+        global :soap_version, 2
+        global :open_timeout, 71
+        global :wsse_auth, "luke", "secret", :digest
+      }
+
+      expect(model.client.globals[:soap_version]).to eq(2)
+      expect(model.client.globals[:open_timeout]).to eq(71)
+      expect(model.client.globals[:wsse_auth]).to eq(["luke", "secret", :digest])
+    end
+  end
+
+  describe ".operations" do
+    it "defines class methods for each operation" do
+      model = Class.new {
+        extend Savon::Model
+
+        client :wsdl => Fixture.wsdl(:authentication)
+        operations :authenticate
+      }
+
+      expect(model).to respond_to(:authenticate)
+    end
+
+    it "executes class-level SOAP operations" do
+      repeat_url = @server.url(:repeat)
+
+      model = Class.new {
+        extend Savon::Model
+
+        client :endpoint => repeat_url, :namespace => "http://v1.example.com"
+        global :log, false
+
+        operations :authenticate
+      }
+
+      response = model.authenticate(:xml => Fixture.response(:authentication))
+      expect(response.body[:authenticate_response][:return]).to include(:authentication_value)
+    end
+
+    it "defines instance methods for each operation" do
+      model = Class.new {
+        extend Savon::Model
+
+        client :wsdl => Fixture.wsdl(:authentication)
+        operations :authenticate
+      }
+
+      model_instance = model.new
+      expect(model_instance).to respond_to(:authenticate)
+    end
+
+    it "executes instance-level SOAP operations" do
+      repeat_url = @server.url(:repeat)
+
+      model = Class.new {
+        extend Savon::Model
+
+        client :endpoint => repeat_url, :namespace => "http://v1.example.com"
+        global :log, false
+
+        operations :authenticate
+      }
+
+      model_instance = model.new
+      response = model_instance.authenticate(:xml => Fixture.response(:authentication))
+      expect(response.body[:authenticate_response][:return]).to include(:authentication_value)
+    end
+  end
+
+  it "allows to overwrite class operations" do
+    repeat_url = @server.url(:repeat)
+
+    model = Class.new {
+      extend Savon::Model
+      client :endpoint => repeat_url, :namespace => "http://v1.example.com"
+    }
+
+    supermodel = model.dup
+    supermodel.operations :authenticate
+
+    def supermodel.authenticate(locals = {})
+      p "super"
+      super
+    end
+
+    supermodel.client.expects(:call).with(:authenticate, :message => { :username => "luke", :password => "secret" })
+    supermodel.expects(:p).with("super")  # stupid, but works
+
+    supermodel.authenticate(:message => { :username => "luke", :password => "secret" })
+  end
+
+  it "allows to overwrite instance operations" do
+    repeat_url = @server.url(:repeat)
+
+    model = Class.new {
+      extend Savon::Model
+      client :endpoint => repeat_url, :namespace => "http://v1.example.com"
+    }
+
+    supermodel = model.dup
+    supermodel.operations :authenticate
+    supermodel = supermodel.new
+
+    def supermodel.authenticate(lcoals = {})
+      p "super"
+      super
+    end
+
+    supermodel.client.expects(:call).with(:authenticate, :message => { :username => "luke", :password => "secret" })
+    supermodel.expects(:p).with("super")  # stupid, but works
+
+    supermodel.authenticate(:message => { :username => "luke", :password => "secret" })
+  end
+
+end

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,211 @@
+require "spec_helper"
+require "integration/support/server"
+require "json"
+require "ostruct"
+
+describe Savon::Operation do
+
+  let(:globals) { Savon::GlobalOptions.new(:endpoint => @server.url(:repeat), :log => false) }
+  let(:wsdl)    { Wasabi::Document.new Fixture.wsdl(:taxcloud) }
+
+  let(:no_wsdl) {
+    wsdl = Wasabi::Document.new
+
+    wsdl.endpoint  = "http://example.com"
+    wsdl.namespace = "http://v1.example.com"
+
+    wsdl
+  }
+
+  def new_operation(operation_name, wsdl, globals)
+    Savon::Operation.create(operation_name, wsdl, globals)
+  end
+
+  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 = new_operation(:verify_address, wsdl, globals)
+      expect(operation).to be_a(Savon::Operation)
+    end
+
+    it "raises if the operation name is not a Symbol" do
+      expect { new_operation("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 { new_operation(:no_such_operation, wsdl, globals) }.
+        to raise_error(Savon::UnknownOperationError, /Unable to find SOAP operation: :no_such_operation/)
+    end
+  end
+
+  describe ".create without a WSDL" do
+    it "returns a new operation" do
+      operation = new_operation(:verify_address, no_wsdl, globals)
+      expect(operation).to be_a(Savon::Operation)
+    end
+  end
+
+  describe "#build" do
+    it "returns the Builder" do
+      operation = new_operation(:verify_address, wsdl, globals)
+      builder = operation.build(:message => { :test => 'message' })
+
+      expect(builder).to be_a(Savon::Builder)
+      expect(builder.to_s).to include('<tns:VerifyAddress><tns:test>message</tns:test></tns:VerifyAddress>')
+    end
+  end
+
+  describe "#call" do
+    it "returns a response object" do
+      operation = new_operation(:verify_address, wsdl, globals)
+      expect(operation.call).to be_a(Savon::Response)
+    end
+
+    it "uses the global :endpoint option for the request" do
+      globals.endpoint("http://v1.example.com")
+      HTTPI::Request.any_instance.expects(:url=).with("http://v1.example.com")
+
+      operation = new_operation(:verify_address, wsdl, globals)
+
+      # stub the actual request
+      http_response = HTTPI::Response.new(200, {}, "")
+      operation.expects(:call_with_logging).returns(http_response)
+
+      operation.call
+    end
+
+    it "falls back to use the WSDL's endpoint if the :endpoint option was not set" do
+      globals_without_endpoint = Savon::GlobalOptions.new(:log => false)
+      HTTPI::Request.any_instance.expects(:url=).with(wsdl.endpoint)
+
+      operation = new_operation(:verify_address, wsdl, globals_without_endpoint)
+
+      # stub the actual request
+      http_response = HTTPI::Response.new(200, {}, "")
+      operation.expects(:call_with_logging).returns(http_response)
+
+      operation.call
+    end
+
+    it "sets the Content-Length header" do
+      # XXX: probably the worst spec ever written. refactor! [dh, 2013-01-05]
+      http_request = HTTPI::Request.new
+      http_request.headers.expects(:[]=).with("Content-Length", "312")
+      Savon::SOAPRequest.any_instance.expects(:build).returns(http_request)
+
+      new_operation(:verify_address, wsdl, globals).call
+    end
+
+    it "passes the local :soap_action option to the request builder" do
+      globals.endpoint @server.url(:inspect_request)
+      soap_action = "http://v1.example.com/VerifyAddress"
+
+      operation = new_operation(:verify_address, wsdl, globals)
+      response  = operation.call(:soap_action => soap_action)
+
+      actual_soap_action = inspect_request(response).soap_action
+      expect(actual_soap_action).to eq(%("#{soap_action}"))
+    end
+
+    it "uses the local :cookies option" do
+      globals.endpoint @server.url(:inspect_request)
+      cookies = [HTTPI::Cookie.new("some-cookie=choc-chip")]
+
+      HTTPI::Request.any_instance.expects(:set_cookies).with(cookies)
+
+      operation = new_operation(:verify_address, wsdl, globals)
+      operation.call(:cookies => cookies)
+    end
+
+    it "passes nil to the request builder if the :soap_action was set to nil" do
+      globals.endpoint @server.url(:inspect_request)
+
+      operation = new_operation(:verify_address, wsdl, globals)
+      response  = operation.call(:soap_action => nil)
+
+      actual_soap_action = inspect_request(response).soap_action
+      expect(actual_soap_action).to be_nil
+    end
+
+    it "gets the SOAP action from the WSDL if available" do
+      globals.endpoint @server.url(:inspect_request)
+
+      operation = new_operation(:verify_address, wsdl, globals)
+      response  = operation.call
+
+      actual_soap_action = inspect_request(response).soap_action
+      expect(actual_soap_action).to eq('"http://taxcloud.net/VerifyAddress"')
+    end
+
+    it "falls back to Gyoku if both option and WSDL are not available" do
+      globals.endpoint @server.url(:inspect_request)
+
+      operation = new_operation(:authenticate, no_wsdl, globals)
+      response  = operation.call
+
+      actual_soap_action = inspect_request(response).soap_action
+      expect(actual_soap_action).to eq(%("authenticate"))
+    end
+
+    it "returns a Savon::Multipart::Response if available and requested globally" do
+      globals.multipart true
+
+      with_multipart_mocked do
+        operation = new_operation(:authenticate, no_wsdl, globals)
+        response = operation.call
+
+        expect(response).to be_a(Savon::Multipart::Response)
+      end
+    end
+
+    it "returns a Savon::Multipart::Response if available and requested locally" do
+      with_multipart_mocked do
+        operation = new_operation(:authenticate, no_wsdl, globals)
+        response = operation.call(:multipart => true)
+
+        expect(response).to be_a(Savon::Multipart::Response)
+      end
+    end
+
+    it "raises if savon-multipart is not available and it was requested globally" do
+      globals.multipart true
+
+      operation = new_operation(:authenticate, no_wsdl, globals)
+
+      expect { operation.call }.
+        to raise_error RuntimeError, /Unable to find Savon::Multipart/
+    end
+
+    it "raises if savon-multipart is not available and it was requested locally" do
+      operation = new_operation(:authenticate, no_wsdl, globals)
+
+      expect { operation.call(:multipart => true) }.
+        to raise_error RuntimeError, /Unable to find Savon::Multipart/
+    end
+  end
+
+  def with_multipart_mocked
+    multipart_response = Class.new { def initialize(*args); end }
+    multipart_mock = Module.new
+    multipart_mock.const_set('Response', multipart_response)
+
+    Savon.const_set('Multipart', multipart_mock)
+
+    yield
+  ensure
+    Savon.send(:remove_const, :Multipart) if Savon.const_defined? :Multipart
+  end
+
+  def inspect_request(response)
+    hash = JSON.parse(response.http.body)
+    OpenStruct.new(hash)
+  end
+end