savon_with_adapter 2.4.1

data/spec/savon/core_ext/string_spec.rb

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

data/spec/savon/features/message_tag_spec.rb

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

@@ -0,0 +1,49 @@
+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_true
+    end
+
+    it "returns false unless there was an HTTP error" do
+      expect(Savon::HTTPError.present? new_response).to be_false
+    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

@@ -0,0 +1,33 @@
+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" do
+    message = log_message("<root><password>secret</password></root>", [:password], 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

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe Savon::Message do
+
+  before do
+    @server = IntegrationServer.run
+  end
+
+  after do
+    @server.stop
+  end
+
+  context "with a qualified message" do
+    it "converts request Hash keys for which there is not namespace" do
+      client = Savon.client(
+        :endpoint => @server.url(:repeat),
+        :namespace => 'http://example.com',
+        :log => false,
+
+        :element_form_default => :qualified,
+        :convert_request_keys_to => :camelcase,
+
+        :convert_response_tags_to => nil
+      )
+
+      message = {
+       :email_count => 3,
+       :user_name   => 'josh',
+       :order!      => [:user_name, :email_count]
+      }
+
+      response = client.call(:something, :message => message)
+      body = response.hash['Envelope']['Body']
+
+      expect(response.xml).to include('<wsdl:UserName>josh</wsdl:UserName><wsdl:EmailCount>3</wsdl:EmailCount>')
+    end
+  end
+
+end

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