savon 2.11.2 → 2.14.0

data/spec/savon/core_ext/string_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-
-describe String do
-
-  describe "snakecase" do
-    it "lowercases one word CamelCase" do
-      expect("Merb".snakecase).to eq("merb")
-    end
-
-    it "makes one underscore snakecase two word CamelCase" do
-      expect("MerbCore".snakecase).to eq("merb_core")
-    end
-
-    it "handles CamelCase with more than 2 words" do
-      expect("SoYouWantContributeToMerbCore".snakecase).to eq("so_you_want_contribute_to_merb_core")
-    end
-
-    it "handles CamelCase with more than 2 capital letter in a row" do
-      expect("CNN".snakecase).to eq("cnn")
-      expect("CNNNews".snakecase).to eq("cnn_news")
-      expect("HeadlineCNNNews".snakecase).to eq("headline_cnn_news")
-    end
-
-    it "does NOT change one word lowercase" do
-      expect("merb".snakecase).to eq("merb")
-    end
-
-    it "leaves snake_case as is" do
-      expect("merb_core".snakecase).to eq("merb_core")
-    end
-
-    it "converts period characters to underscores" do
-      expect("User.GetEmail".snakecase).to eq("user_get_email")
-    end
-  end
-
-end

data/spec/savon/features/message_tag_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe Savon do
-
-  it 'knows the message tag for :authentication' do
-    message_tag = message_tag_for(:authentication, :authenticate)
-    expect(message_tag).to eq(['http://v1_0.ws.auth.order.example.com/', 'authenticate'])
-  end
-
-  it 'knows the message tag for :taxcloud' do
-    message_tag = message_tag_for(:taxcloud, :verify_address)
-    expect(message_tag).to eq(['http://taxcloud.net', 'VerifyAddress'])
-  end
-
-  it 'knows the message tag for :team_software' do
-    message_tag = message_tag_for(:team_software, :login)
-    expect(message_tag).to eq(['http://tempuri.org/', 'Login'])
-  end
-
-  it 'knows the message tag for :interhome' do
-    message_tag = message_tag_for(:interhome, :price_list)
-    expect(message_tag).to eq(['http://www.interhome.com/webservice', 'PriceList'])
-  end
-
-  it 'knows the message tag for :betfair' do
-    message_tag = message_tag_for(:betfair, :get_bet)
-    expect(message_tag).to eq(['http://www.betfair.com/publicapi/v5/BFExchangeService/', 'getBet'])
-  end
-
-  it 'knows the message tag for :vies' do
-    message_tag = message_tag_for(:vies, :check_vat)
-    expect(message_tag).to eq(['urn:ec.europa.eu:taxud:vies:services:checkVat:types', 'checkVat'])
-  end
-
-  it 'knows the message tag for :wasmuth' do
-    message_tag = message_tag_for(:wasmuth, :get_st_tables)
-    expect(message_tag).to eq(['http://ws.online.msw/', 'getStTables'])
-  end
-
-  def message_tag_for(fixture, operation_name)
-    globals     = Savon::GlobalOptions.new(:log => false)
-    wsdl        = Wasabi::Document.new Fixture.wsdl(fixture)
-    operation   = Savon::Operation.create(operation_name, wsdl, globals)
-    request_xml = operation.build.to_s
-
-    nsid, local = extract_message_tag_from_request(request_xml)
-    namespace   = extract_namespace_from_request(nsid, request_xml)
-
-    [namespace, local]
-  end
-
-  def extract_message_tag_from_request(xml)
-    match = xml.match(/<\w+?:Body><(.+?):(.+?)>/)
-    [ match[1], match[2] ]
-  end
-
-  def extract_namespace_from_request(nsid, xml)
-    xml.match(/xmlns:#{nsid}="(.+?)"/)[1]
-  end
-
-end

data/spec/savon/http_error_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe Savon::HTTPError do
-  let(:http_error) { Savon::HTTPError.new new_response(:code => 404, :body => "Not Found") }
-  let(:no_error) { Savon::HTTPError.new new_response }
-
-  it "inherits from Savon::Error" do
-    expect(Savon::HTTPError.ancestors).to include(Savon::Error)
-  end
-
-  describe ".present?" do
-    it "returns true if there was an HTTP error" do
-      http = new_response(:code => 404, :body => "Not Found")
-      expect(Savon::HTTPError.present? http).to be_truthy
-    end
-
-    it "returns false unless there was an HTTP error" do
-      expect(Savon::HTTPError.present? new_response).to be_falsey
-    end
-  end
-
-  describe "#http" do
-    it "returns the HTTPI::Response" do
-      expect(http_error.http).to be_a(HTTPI::Response)
-    end
-  end
-
-  [:message, :to_s].each do |method|
-    describe "##{method}" do
-      it "returns the HTTP error message" do
-        expect(http_error.send method).to eq("HTTP error (404): Not Found")
-      end
-    end
-  end
-
-  describe "#to_hash" do
-    it "returns the HTTP response details as a Hash" do
-      expect(http_error.to_hash).to eq(:code => 404, :headers => {}, :body => "Not Found")
-    end
-  end
-
-  def new_response(options = {})
-    defaults = { :code => 200, :headers => {}, :body => Fixture.response(:authentication) }
-    response = defaults.merge options
-
-    HTTPI::Response.new response[:code], response[:headers], response[:body]
-  end
-
-end

data/spec/savon/log_message_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-
-describe Savon::LogMessage do
-
-  it "returns the message if it's not XML" do
-    message = log_message("hello", [:password], :pretty_print).to_s
-    expect(message).to eq("hello")
-  end
-
-  it "returns the message if it shouldn't be filtered or pretty printed" do
-    Nokogiri.expects(:XML).never
-
-    message = log_message("<hello/>", [], false).to_s
-    expect(message).to eq("<hello/>")
-  end
-
-  it "pretty prints a given message" do
-    message = log_message("<envelope><body>hello</body></envelope>", [], :pretty_print).to_s
-
-    expect(message).to include("\n<envelope>")
-    expect(message).to include("\n  <body>")
-  end
-
-  it "filters tags in a given message without pretty printing" do
-    message = log_message("<root><password>secret</password></root>", [:password], false).to_s
-    expect(message).to include("<password>***FILTERED***</password>")
-    expect(message).to_not include("\n  <password>***FILTERED***</password>") # no pretty printing
-  end
-
-  it "filters tags in a given message with pretty printing" do
-    message = log_message("<root><password>secret</password></root>", [:password], true).to_s
-    expect(message).to include("\n  <password>***FILTERED***</password>")
-  end
-
-  it "properly applies Proc filter" do
-    filter = Proc.new do |document|
-      document.xpath('//password').each do |node|
-        node.content = "FILTERED"
-      end
-    end
-
-    message = log_message("<root><password>secret</password></root>", [filter], false).to_s
-    expect(message).to include("<password>FILTERED</password>")
-  end
-
-  def log_message(*args)
-    Savon::LogMessage.new(*args)
-  end
-
-end

data/spec/savon/message_spec.rb

@@ -1,70 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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

@@ -1,182 +0,0 @@
-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