savon-SU 2.11.1b

data/spec/savon/client_spec.rb

@@ -0,0 +1,271 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe Savon::Client do
+
+  before :all do
+    @server = IntegrationServer.run
+  end
+
+  after :all do
+    @server.stop
+  end
+
+  describe ".new" do
+    it "supports a block without arguments to create a client with global options" do
+      client = Savon.client do
+        wsdl Fixture.wsdl(:authentication)
+      end
+
+      expect(client.globals[:wsdl]).to eq(Fixture.wsdl(:authentication))
+    end
+
+    it "supports a block with one argument to create a client with global options" do
+      client = Savon.client do |globals|
+        globals.wsdl Fixture.wsdl(:authentication)
+      end
+
+      expect(client.globals[:wsdl]).to eq(Fixture.wsdl(:authentication))
+    end
+
+    it "builds an HTTPI request for Wasabi" do
+      http_request = mock
+      wsdl_request = mock(:build => http_request)
+      Savon::WSDLRequest.expects(:new).with(instance_of(Savon::GlobalOptions)).returns(wsdl_request)
+
+      Wasabi::Document.any_instance.expects(:request=).with(http_request)
+      Savon.client(:wsdl => "http://example.com")
+    end
+
+    it "raises if initialized with anything other than a Hash" do
+      expect { Savon.client("http://example.com") }.
+        to raise_error(Savon::InitializationError, /Some code tries to initialize Savon with the "http:\/\/example\.com" \(String\)/)
+    end
+
+    it "raises if not initialized with either a :wsdl or both :endpoint and :namespace options" do
+      expect { Savon.client(:endpoint => "http://example.com") }.
+        to raise_error(Savon::InitializationError, /Expected either a WSDL document or the SOAP endpoint and target namespace options/)
+    end
+
+    it "raises a when given an unknown option via the Hash syntax" do
+      expect { Savon.client(:invalid_global_option => true) }.
+        to raise_error(Savon::UnknownOptionError, "Unknown global option: :invalid_global_option")
+    end
+
+    it "raises a when given an unknown option via the block syntax" do
+      expect { Savon.client { another_invalid_global_option true } }.
+        to raise_error(Savon::UnknownOptionError, "Unknown global option: :another_invalid_global_option")
+    end
+  end
+
+  describe "#globals" do
+    it "returns the current set of global options" do
+      expect(new_client.globals).to be_an_instance_of(Savon::GlobalOptions)
+    end
+
+    fit "defaults :log to false" do
+      client = Savon.client(:wsdl => Fixture.wsdl(:authentication))
+      expect(client.globals[:log]).to be_falsey
+    end
+  end
+
+  describe "#service_name" do
+    it "returns the name of the service" do
+      expect(new_client.service_name).to eq('AuthenticationWebServiceImplService')
+    end
+  end
+
+  describe "#operations" do
+    it "returns all operation names" do
+      operations = new_client.operations
+      expect(operations).to eq([:authenticate])
+    end
+
+    it "raises when there is no WSDL document" do
+      expect { new_client_without_wsdl.operations }.to raise_error("Unable to inspect the service without a WSDL document.")
+    end
+  end
+
+  describe "#operation" do
+    it "returns a new SOAP operation" do
+      operation = new_client.operation(:authenticate)
+      expect(operation).to be_a(Savon::Operation)
+    end
+
+    it "raises if there's no such SOAP operation" do
+      expect { new_client.operation(:does_not_exist) }.
+        to raise_error(Savon::UnknownOperationError)
+    end
+
+    it "does not raise when there is no WSDL document" do
+      new_client_without_wsdl.operation(:does_not_exist)
+    end
+  end
+
+  describe "#call" do
+    it "calls a new SOAP operation" do
+      locals = { :message => { :symbol => "AAPL" } }
+      soap_response = new_soap_response
+
+      wsdl = Wasabi::Document.new('http://example.com')
+      operation = Savon::Operation.new(:authenticate, wsdl, Savon::GlobalOptions.new)
+      operation.expects(:call).with(locals).returns(soap_response)
+
+      Savon::Operation.expects(:create).with(
+        :authenticate,
+        instance_of(Wasabi::Document),
+        instance_of(Savon::GlobalOptions)
+      ).returns(operation)
+
+      response = new_client.call(:authenticate, locals)
+      expect(response).to eq(soap_response)
+    end
+
+    it "supports a block without arguments to call an operation with local options" do
+      client = new_client(:endpoint => @server.url(:repeat))
+
+      response = client.call(:authenticate) do
+        message(:symbol => "AAPL" )
+      end
+
+      expect(response.http.body).to include("<symbol>AAPL</symbol>")
+    end
+
+    it "supports a block with one argument to call an operation with local options" do
+      client = new_client(:endpoint => @server.url(:repeat))
+
+      # supports instance variables!
+      @instance_variable = { :symbol => "AAPL" }
+
+      response = client.call(:authenticate) do |locals|
+        locals.message(@instance_variable)
+      end
+
+      expect(response.http.body).to include("<symbol>AAPL</symbol>")
+    end
+
+    it "accepts arguments for the message tag" do
+      client   = new_client(:endpoint => @server.url(:repeat))
+      response = client.call(:authenticate, :attributes => { "ID" => "ABC321"})
+
+      expect(response.http.body).to include('<tns:authenticate ID="ABC321">')
+    end
+
+    it "raises when the operation name is not a symbol" do
+      expect { new_client.call("not a symbol") }.to raise_error(
+        ArgumentError,
+        "Expected the first parameter (the name of the operation to call) to be a symbol\n" \
+        "Actual: \"not a symbol\" (String)"
+      )
+    end
+
+    it "raises a when given an unknown option via the Hash syntax" do
+      expect { new_client.call(:authenticate, :invalid_local_option => true) }.
+        to raise_error(Savon::UnknownOptionError, "Unknown local option: :invalid_local_option")
+    end
+
+    it "raises a when given an unknown option via the block syntax" do
+      expect { new_client.call(:authenticate) { another_invalid_local_option true } }.
+        to raise_error(Savon::UnknownOptionError, "Unknown local option: :another_invalid_local_option")
+    end
+  end
+
+  describe "#build_request" do
+    it "returns the request without making an actual call" do
+      expected_request = mock('request')
+      wsdl = Wasabi::Document.new('http://example.com')
+
+      operation = Savon::Operation.new(
+        :authenticate,
+        wsdl,
+        Savon::GlobalOptions.new
+      )
+      operation.expects(:request).returns(expected_request)
+
+      Savon::Operation.expects(:create).with(
+        :authenticate,
+        instance_of(Wasabi::Document),
+        instance_of(Savon::GlobalOptions)
+      ).returns(operation)
+
+      operation.expects(:call).never
+
+      client = new_client(:endpoint => @server.url(:repeat))
+      request = client.build_request(:authenticate) do
+        message(:symbol => "AAPL" )
+      end
+
+      expect(request).to eq expected_request
+    end
+
+    it "accepts a block without arguments" do
+      client = new_client(:endpoint => @server.url(:repeat))
+      request = client.build_request(:authenticate) do
+        message(:symbol => "AAPL" )
+      end
+
+      expect(request.body).
+        to include('<tns:authenticate><symbol>AAPL</symbol></tns:authenticate>')
+    end
+
+    it "accepts a block with one argument" do
+      client = new_client(:endpoint => @server.url(:repeat))
+
+      # supports instance variables!
+      @instance_variable = { :symbol => "AAPL" }
+
+      request = client.build_request(:authenticate) do |locals|
+        locals.message(@instance_variable)
+      end
+
+      expect(request.body).
+        to include("<tns:authenticate><symbol>AAPL</symbol></tns:authenticate>")
+    end
+
+    it "accepts argument for the message tag" do
+      client = new_client(:endpoint => @server.url(:repeat))
+      request = client.build_request(:authenticate, :attributes => { "ID" => "ABC321" })
+
+      expect(request.body).
+        to include("<tns:authenticate ID=\"ABC321\"></tns:authenticate>")
+    end
+
+    it "raises when the operation name is not a symbol" do
+      expect { new_client.build_request("not a symbol") }.to raise_error
+    end
+
+    it "raises when given an unknown option via the Hash syntax" do
+      expect { new_client.build_request(:authenticate, :invalid_local_option => true) }.to raise_error
+    end
+
+    it "raises when given an unknown option via the block syntax" do
+      expect { new_client.build_request(:authenticate) { another_invalid_local_option true } }.to raise_error
+    end
+  end
+
+  def new_http_response(options = {})
+    defaults = { :code => 200, :headers => {}, :body => Fixture.response(:authentication) }
+    response = defaults.merge options
+
+    HTTPI::Response.new response[:code], response[:headers], response[:body]
+  end
+
+  def new_soap_response(options = {})
+    http = new_http_response(options)
+    globals = Savon::GlobalOptions.new
+    locals = Savon::LocalOptions.new
+
+    Savon::Response.new(http, globals, locals)
+  end
+
+  def new_client(globals = {})
+    globals = { :wsdl => Fixture.wsdl(:authentication), :log => false }.merge(globals)
+    Savon.client(globals)
+  end
+
+  def new_client_without_wsdl(globals = {})
+    globals = { :endpoint => "http://example.co", :namespace => "http://v1.example.com", :log => false }.merge(globals)
+    Savon.client(globals)
+  end
+
+end

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
+      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

@@ -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_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

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