savon 2.13.1 → 2.14.0

data/spec/savon/message_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "integration/support/server"
-
-RSpec.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
-  end
-
-end

data/spec/savon/mock_spec.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "savon/mock/spec_helper"
-
-RSpec.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

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "integration/support/server"
-
-RSpec.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/multipart_request_spec.rb

@@ -1,46 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Savon::Builder do
-
-  let(:globals)     { Savon::GlobalOptions.new({ :endpoint => "http://example.co", :namespace => "http://v1.example.com" }) }
-  let(:no_wsdl)     { Wasabi::Document.new }
-
-  it "building multipart request from inline content" do
-    locals = {
-      attachments: [
-        { filename: 'x1.xml', content: '<xml>abc1</xml>'},
-        { filename: 'x2.xml', content: '<xml>abc2</xml>'},
-      ]
-    }
-    builder = Savon::Builder.new(:operation1, no_wsdl, globals, Savon::LocalOptions.new(locals))
-    request_body = builder.to_s
-
-    expect(request_body).to include('Content-Type')
-    expect(request_body).to match(/<[a-z]+:operation1>/)
-
-    locals[:attachments].each do |attachment|
-      expect(request_body).to match(/^Content-Location: #{attachment[:filename]}\s$/)
-      expect(request_body).to include(Base64.encode64(attachment[:content]).strip)
-    end
-
-  end
-
-  it "building multipart request from file" do
-    locals = {
-      attachments: {
-        'file.gz' => File.expand_path("../../fixtures/gzip/message.gz", __FILE__)
-      }
-    }
-    builder = Savon::Builder.new(:operation1, no_wsdl, globals, Savon::LocalOptions.new(locals))
-    request_body = builder.to_s
-
-    expect(request_body).to include('Content-Type')
-    expect(request_body).to match(/<[a-z]+:operation1>/)
-
-    locals[:attachments].each do |id, file|
-      expect(request_body).to match(/^Content-Location: #{id}\s$/)
-      expect(request_body.gsub("\r", "")).to include(Base64.encode64(File.read(file)).strip)
-    end
-
-  end
-end

data/spec/savon/observers_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "integration/support/server"
-
-RSpec.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