savon-SU 2.11.1b

data/spec/savon/message_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe Savon::Message do
+
+  before do
+    @server = IntegrationServer.run
+  end
+
+  after do
+    @server.stop
+  end
+
+  let(:client_config) {
+    {
+      :endpoint => @server.url(:repeat),
+      :namespace => 'http://example.com',
+      :log => false,
+
+      :element_form_default => :qualified,
+      :convert_request_keys_to => :camelcase,
+
+      :convert_response_tags_to => nil
+    }
+  }
+
+  let(:client) { Savon.client(client_config) }
+
+  context "with a qualified message" do
+    let(:message) {
+      {
+       :email_count => 3,
+       :user_name   => 'josh',
+       :order!      => [:user_name, :email_count]
+      }
+    }
+
+    let(:converted_keys) {
+      '<wsdl:UserName>josh</wsdl:UserName><wsdl:EmailCount>3</wsdl:EmailCount>'
+    }
+    it "converts request Hash keys for which there is not namespace" do
+      response = client.call(:something, :message => message)
+      expect(response.xml).to include(converted_keys)
+    end
+  end
+
+  context 'use_wsa_headers' do
+    let(:client_config) { super().merge(use_wsa_headers: true) }
+
+    context 'headers' do
+      [ 'wsa:Action', 'wsa:To', 'wsa:MessageID' ].each do |header|
+        it "should include #{header} header" do
+          response = client.call(:something, message: {})
+          expect(response.xml).to include(header)
+        end
+      end
+    end
+
+    context 'wsa:MessageID' do
+      let(:message_id_tag) {
+        '<wsa:MessageID xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing">'
+      }
+      it 'should include xmlns:wsa attribute' do
+        response = client.call(:something, message: {})
+        expect(response.xml).to include(message_id_tag)
+      end
+    end
+  end
+
+end

data/spec/savon/mock_spec.rb

@@ -0,0 +1,174 @@
+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 "can verify a request with any parameters and return a fixture response" do
+    message = { :username => "luke", :password => :any }
+    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 "matchers can be used to specify the message" do
+    savon.expects(:find_user).with(:message => include(:username)).returns("<fixture/>")
+    message = { :username => "Han Solo", password: "querty"}
+
+    expect { new_client.call(:find_user, :message => message) }.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,182 @@
+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
+
+  describe ".all_operations" do
+    it "should call operations with all available client operations" do
+      model = Class.new {
+        extend Savon::Model
+
+        client :wsdl => Fixture.wsdl(:taxcloud)
+        all_operations
+      }
+
+      [:verify_address,
+      :lookup_for_date,
+      :lookup,
+      :authorized,
+      :authorized_with_capture,
+      :captured,
+      :returned,
+      :get_tic_groups,
+      :get_ti_cs,
+      :get_ti_cs_by_group,
+      :add_exempt_certificate,
+      :delete_exempt_certificate,
+      :get_exempt_certificates].each do |method|
+        expect(model).to respond_to(method)
+      end
+    end
+
+  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