savon_with_adapter 2.4.1

data/spec/integration/ratp_example_spec.rb

@@ -0,0 +1,28 @@
+ require "spec_helper"
+
+describe "RATP example" do
+
+  it "retrieves information about a specific station" do
+    client = Savon.client do
+      # The WSDL document provided by the service.
+      wsdl "http://www.ratp.fr/wsiv/services/Wsiv?wsdl"
+
+      # Lower timeouts so these specs don't take forever when the service is not available.
+      open_timeout 10
+      read_timeout 10
+
+      # Disable logging for cleaner spec output.
+      log false
+    end
+
+    # XXX: the service seems to rely on the order of arguments.
+    #      try to fix this with the new wsdl parser.
+    response = call_and_fail_gracefully(client, :get_stations) do
+      message(:station => { :id => 1975 }, :limit => 1)
+    end
+
+    station_name = response.body[:get_stations_response][:return][:stations][:name]
+    expect(station_name).to eq("Cite")
+  end
+
+end

data/spec/integration/stockquote_example_spec.rb

@@ -0,0 +1,28 @@
+ require "spec_helper"
+
+describe "Stockquote example" do
+
+  it "returns the result in a CDATA tag" do
+    client = Savon.client(
+      # The WSDL document provided by the service.
+      :wsdl => "http://www.webservicex.net/stockquote.asmx?WSDL",
+
+      # Lower timeouts so these specs don't take forever when the service is not available.
+      :open_timeout => 10,
+      :read_timeout => 10,
+
+      # Disable logging for cleaner spec output.
+      :log => false
+    )
+
+    response = call_and_fail_gracefully(client, :get_quote, :message => { :symbol => "AAPL" })
+
+    cdata = response.body[:get_quote_response][:get_quote_result]
+
+    nori_options = { :convert_tags_to => lambda { |tag| tag.snakecase.to_sym } }
+    result = Nori.new(nori_options).parse(cdata)
+
+    result[:stock_quotes][:stock][:symbol].should == "AAPL"
+  end
+
+end

data/spec/integration/support/application.rb

@@ -0,0 +1,82 @@
+require "rack/builder"
+require "json"
+
+class IntegrationServer
+
+  def self.respond_with(options = {})
+    code = options.fetch(:code, 200)
+    body = options.fetch(:body, "")
+    headers = { "Content-Type" => "text/plain", "Content-Length" => body.size.to_s }
+
+    [code, headers, [body]]
+  end
+
+  Application = Rack::Builder.new do
+
+    map "/" do
+      run lambda { |env|
+        IntegrationServer.respond_with :body => env["REQUEST_METHOD"].downcase
+      }
+    end
+
+    map "/repeat" do
+      run lambda { |env|
+        # stupid way of extracting the value from a query string (e.g. "code=500") [dh, 2012-12-08]
+        IntegrationServer.respond_with :body => env["rack.input"].read
+      }
+    end
+
+    map "/404" do
+      run lambda { |env|
+        IntegrationServer.respond_with :code => 404, :body => env["rack.input"].read
+      }
+    end
+
+    map "/timeout" do
+      run lambda { |env|
+        sleep 2
+        IntegrationServer.respond_with :body => "timeout"
+      }
+    end
+
+    map "/inspect_request" do
+      run lambda { |env|
+        body = {
+          :soap_action  => env["HTTP_SOAPACTION"],
+          :cookie       => env["HTTP_COOKIE"],
+          :x_token      => env["HTTP_X_TOKEN"],
+          :content_type => env["CONTENT_TYPE"]
+        }
+
+        IntegrationServer.respond_with :body => JSON.dump(body)
+      }
+    end
+
+    map "/basic_auth" do
+      use Rack::Auth::Basic, "basic-realm" do |username, password|
+        username == "admin" && password == "secret"
+      end
+
+      run lambda { |env|
+        IntegrationServer.respond_with :body => "basic-auth"
+      }
+    end
+
+    map "/digest_auth" do
+      unprotected_app = lambda { |env|
+        IntegrationServer.respond_with :body => "digest-auth"
+      }
+
+      realm = 'digest-realm'
+      app = Rack::Auth::Digest::MD5.new(unprotected_app) do |username|
+        username == 'admin' ? Digest::MD5.hexdigest("admin:#{realm}:secret") : nil
+      end
+      app.realm = realm
+      app.opaque = 'this-should-be-secret'
+      app.passwords_hashed = true
+
+      run app
+    end
+
+  end
+end

data/spec/integration/support/server.rb

@@ -0,0 +1,84 @@
+require "puma"
+require "puma/minissl"
+
+require "integration/support/application"
+
+class IntegrationServer
+
+  def self.run(options = {})
+    server = new(options)
+    server.run
+    server
+  end
+
+  def self.ssl_ca_file;   integration_fixture("ca_all.pem")  end
+  def self.ssl_key_file;  integration_fixture("server.key")  end
+  def self.ssl_cert_file; integration_fixture("server.cert") end
+
+  def self.integration_fixture(file)
+    file = File.expand_path("../../fixtures/#{file}", __FILE__)
+    raise "No such file '#{file}'" unless File.exist? file
+    file
+  end
+
+  def initialize(options = {})
+    @app  = Application
+    @host = options.fetch(:host, "localhost")
+    @port = options.fetch(:port, 17172)
+    @ssl  = options.fetch(:ssl, false)
+
+    @server = Puma::Server.new(app, events)
+
+    if ssl?
+      add_ssl_listener
+    else
+      add_tcp_listener
+    end
+  end
+
+  attr_reader :app, :host, :port, :server
+
+  def url(path = "")
+    protocol = ssl? ? "https" : "http"
+    File.join "#{protocol}://#{host}:#{port}/", path.to_s
+  end
+
+  def ssl?
+    @ssl
+  end
+
+  def run
+    server.run
+  end
+
+  def stop
+    server.stop(true)
+  end
+
+  private
+
+  def events
+    Puma::Events.new($stdout, $stderr)
+  end
+
+  def add_tcp_listener
+    server.add_tcp_listener(host, port)
+  rescue Errno::EADDRINUSE
+    raise "Panther is already running at #{url}"
+  end
+
+  def add_ssl_listener
+    server.add_ssl_listener(host, port, ssl_context)
+  end
+
+  def ssl_context
+    context = Puma::MiniSSL::Context.new
+
+    context.key         = IntegrationServer.ssl_key_file
+    context.cert        = IntegrationServer.ssl_cert_file
+    context.verify_mode = Puma::MiniSSL::VERIFY_PEER
+
+    context
+  end
+
+end

data/spec/integration/temperature_example_spec.rb

@@ -0,0 +1,46 @@
+ require "spec_helper"
+
+describe "Temperature example" do
+
+  it "converts 30 degrees celsius to 86 degrees fahrenheit" do
+    client = Savon.client do
+      # The WSDL document provided by the service.
+      wsdl "http://www.webservicex.net/ConvertTemperature.asmx?WSDL"
+
+      # Needed because (up until now), Savon doesn't match XS types to Hash keys,
+      # but defaults to convert Hash message Symbols (like :from_unit) to lowerCamelCase.
+      # The service expects these to be CamelCase instead. Look at Savon's log output
+      # and compare it with an example request generated by soapUI.
+      convert_request_keys_to :camelcase
+
+      # Lower timeouts so these specs don't take forever when the service is not available.
+      open_timeout 10
+      read_timeout 10
+
+      # Disable logging for cleaner spec output.
+      log false
+    end
+
+    response = call_and_fail_gracefully(client, :convert_temp) do
+      # For the corrent values to pass for :from_unit and :to_unit, I searched the WSDL for
+      # the "FromUnit" type which is a "TemperatureUnit" enumeration that looks like this:
+      #
+      # <s:simpleType name="TemperatureUnit">
+      #   <s:restriction base="s:string">
+      #     <s:enumeration value="degreeCelsius"/>
+      #     <s:enumeration value="degreeFahrenheit"/>
+      #     <s:enumeration value="degreeRankine"/>
+      #     <s:enumeration value="degreeReaumur"/>
+      #     <s:enumeration value="kelvin"/>
+      #   </s:restriction>
+      # </s:simpleType>
+      #
+      # Support for XS schema types needs to be improved.
+      message(:temperature => 30, :from_unit => "degreeCelsius", :to_unit => "degreeFahrenheit")
+    end
+
+    fahrenheit = response.body[:convert_temp_response][:convert_temp_result]
+    expect(fahrenheit).to eq("86")
+  end
+
+end

data/spec/integration/zipcode_example_spec.rb

@@ -0,0 +1,42 @@
+ require "spec_helper"
+
+describe "ZIP code example" do
+
+  it "supports threads making requests simultaneously" do
+    client = Savon.client(
+      # The WSDL document provided by the service.
+      :wsdl => "http://www.thomas-bayer.com/axis2/services/BLZService?wsdl",
+
+      # Lower timeouts so these specs don't take forever when the service is not available.
+      :open_timeout => 10,
+      :read_timeout => 10,
+
+      # Disable logging for cleaner spec output.
+      :log => false
+    )
+
+    mutex = Mutex.new
+
+    request_data = [70070010, 24050110, 20050550]
+    threads_waiting = request_data.size
+
+    threads = request_data.map do |blz|
+      thread = Thread.new do
+        response = call_and_fail_gracefully client, :get_bank, :message => { :blz => blz }
+        Thread.current[:value] = response.body[:get_bank_response][:details]
+        mutex.synchronize { threads_waiting -= 1 }
+      end
+
+      thread.abort_on_exception = true
+      thread
+    end
+
+    sleep(1) until threads_waiting == 0
+
+    threads.each(&:kill)
+    values = threads.map { |thr| thr[:value] }.compact
+
+    values.uniq.size.should == values.size
+  end
+
+end

data/spec/savon/builder_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe Savon::Builder do
+
+  subject(:builder) { Savon::Builder.new(:authenticate, wsdl, globals, locals) }
+
+  let(:globals)     { Savon::GlobalOptions.new }
+  let(:locals)      { Savon::LocalOptions.new }
+  let(:wsdl)        { Wasabi::Document.new Fixture.wsdl(:authentication) }
+  let(:no_wsdl)     { Wasabi::Document.new }
+
+  describe "#pretty" do
+    it "returns the pretty printed request" do
+      expect(builder.pretty).to include("<env:Body>\n    <tns:authenticate/>")
+    end
+  end
+
+  describe "#to_s" do
+    it "includes the global :env_namespace if it's available" do
+      globals[:env_namespace] = :soapenv
+      expect(builder.to_s).to include("<soapenv:Envelope")
+    end
+
+    it "defaults to include the default envelope namespace of :env" do
+      expect(builder.to_s).to include("<env:Envelope")
+    end
+
+    it "includes the target namespace from the WSDL" do
+      expect(builder.to_s).to include('xmlns:tns="http://v1_0.ws.auth.order.example.com/"')
+    end
+
+    it "includes the target namespace from the global :namespace if it's available" do
+      globals[:namespace] = "http://v1.example.com"
+      expect(builder.to_s).to include('xmlns:tns="http://v1.example.com"')
+    end
+
+    it "includes the local :message_tag if available" do
+      locals[:message_tag] = "doAuthenticate"
+      expect(builder.to_s).to include("<tns:doAuthenticate>")
+    end
+
+    it "includes the message tag from the WSDL if its available" do
+      expect(builder.to_s).to include("<tns:authenticate>")
+    end
+
+    it "includes a message tag created by Gyoku if both option and WSDL are missing" do
+      globals[:namespace] = "http://v1.example.com"
+
+      locals = Savon::LocalOptions.new
+      builder = Savon::Builder.new(:authenticate, no_wsdl, globals, locals)
+
+      expect(builder.to_s).to include("<wsdl:authenticate>")
+    end
+
+    it "uses the global :namespace_identifier option if it's available" do
+      globals[:namespace_identifier] = :v1
+      expect(builder.to_s).to include("<v1:authenticate>")
+    end
+
+    it "uses the WSDL's namespace_identifier if the global option was not specified" do
+      expect(builder.to_s).to include("<tns:authenticate>")
+    end
+
+    it "uses the default :wsdl identifier if both option and WSDL were not specified" do
+      globals[:namespace] = "http://v1.example.com"
+
+      builder = Savon::Builder.new(:authenticate, no_wsdl, globals, locals)
+      expect(builder.to_s).to include("<wsdl:authenticate>")
+    end
+
+    it "uses the global :element_form_default option if it's available " do
+      globals[:element_form_default] = :qualified
+      locals[:message] = { :username => "luke", :password => "secret" }
+
+      expect(builder.to_s).to include("<tns:username>luke</tns:username>")
+    end
+
+    it "uses the WSDL's element_form_default value if the global option was set specified" do
+      locals[:message] = { :username => "luke", :password => "secret" }
+      wsdl.element_form_default = :qualified
+
+      expect(builder.to_s).to include("<tns:username>luke</tns:username>")
+    end
+  end
+
+end

data/spec/savon/client_spec.rb

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