savon 1.2.0 → 2.0.0

data/spec/integration/request_spec.rb

@@ -1,22 +1,23 @@
-require "spec_helper"
+ require "spec_helper"
 
-describe "Integration" do
+describe "Requests" do
 
   subject(:client) {
-    client = Savon.client(service_endpoint)
-    client.http.open_timeout = 10
-    client.http.read_timeout = 10
-    client
+    Savon.client(:wsdl => service_endpoint, :open_timeout => 10, :read_timeout => 10,
+                 :raise_errors => false, :log => false)
   }
 
   context "stockquote" do
     let(:service_endpoint) { "http://www.webservicex.net/stockquote.asmx?WSDL" }
 
     it "returns the result in a CDATA tag" do
-      response = client.request(:get_quote, :body => { :symbol => "AAPL" })
+      response = client.call(: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)
 
-      cdata = response[:get_quote_response][:get_quote_result]
-      result = Nori.parse(cdata)
       result[:stock_quotes][:stock][:symbol].should == "AAPL"
     end
   end
@@ -25,10 +26,15 @@ describe "Integration" do
     let(:service_endpoint) { "http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx?wsdl" }
 
     it "passes Strings as they are" do
-      response = client.request(:verify_email, :body => { :email => "soap@example.com", "LicenseKey" => "?" })
+      response = client.call(:verify_email, :message => { :email => "soap@example.com", "LicenseKey" => "?" })
 
-      response_text = response[:verify_email_response][:verify_email_result][:response_text]
-      response_text.should == "Email Domain Not Found"
+      response_text = response.body[:verify_email_response][:verify_email_result][:response_text]
+
+      if response_text == "Current license key only allows so many checks"
+        pending "API limit exceeded"
+      else
+        response_text.should == "Email Domain Not Found"
+      end
     end
   end
 
@@ -42,20 +48,29 @@ describe "Integration" do
       threads_waiting = request_data.size
 
       threads = request_data.map do |blz|
-        Thread.new do
-          response = client.request :get_bank, :body => { :blz => blz }
-          Thread.current[:value] = response[:get_bank_response][:details]
+        thread = Thread.new do
+          response = client.call :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
+      threads.each(&:kill)
       values = threads.map { |thr| thr[:value] }.compact
 
       values.uniq.size.should == values.size
     end
   end
 
+  context "redirectes" do
+    it "follows 301 redirects"
+    it "follows 302 redirects"
+    it "follows 307 redirects"
+  end
+
 end

data/spec/integration/support/application.rb

@@ -0,0 +1,80 @@
+require "rack/builder"
+
+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 "/repeat_header" do
+      run lambda { |env|
+        IntegrationServer.respond_with :body => env["HTTP_REPEAT_HEADER"]
+      }
+    end
+
+    map "/inspect_header" do
+      run lambda { |env|
+        IntegrationServer.respond_with :body => env[env["HTTP_INSPECT"]]
+      }
+    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/savon/builder_spec.rb

@@ -0,0 +1,81 @@
+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 "#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

@@ -1,556 +1,158 @@
 require "spec_helper"
+require "integration/support/server"
 
 describe Savon::Client do
-  let(:client) { Savon::Client.new { wsdl.document = Endpoint.wsdl } }
 
-  describe ".new" do
-    context "with a String" do
-      it "should set the WSDL document" do
-        wsdl = "http://example.com/UserService?wsdl"
-        client = Savon::Client.new(wsdl)
-        client.wsdl.instance_variable_get("@document").should == wsdl
-      end
-    end
-
-    context "with a block expecting one argument" do
-      it "should yield the WSDL object" do
-        Savon::Client.new { |wsdl| wsdl.should be_a(Wasabi::Document) }
-      end
-    end
-
-    context "with a block expecting two arguments" do
-      it "should yield the WSDL and HTTP objects" do
-        Savon::Client.new do |wsdl, http|
-          wsdl.should be_an(Wasabi::Document)
-          http.should be_an(HTTPI::Request)
-        end
-      end
-    end
-
-    context "with a block expecting three arguments" do
-      it "should yield the WSDL, HTTP and WSSE objects" do
-        Savon::Client.new do |wsdl, http, wsse|
-          wsdl.should be_an(Wasabi::Document)
-          http.should be_an(HTTPI::Request)
-          wsse.should be_an(Akami::WSSE)
-        end
-      end
-    end
-
-    context "with a block expecting no arguments" do
-      it "should let you access the WSDL object" do
-        Savon::Client.new { wsdl.should be_a(Wasabi::Document) }
-      end
-
-      it "should let you access the HTTP object" do
-        Savon::Client.new { http.should be_an(HTTPI::Request) }
-      end
-
-      it "should let you access the WSSE object" do
-        Savon::Client.new { wsse.should be_a(Akami::WSSE) }
-      end
-    end
-  end
-
-  describe "#wsdl" do
-    it "should return the Savon::Wasabi::Document" do
-      client.wsdl.should be_a(Wasabi::Document)
-    end
-  end
-
-  describe "#http" do
-    it "should return the HTTPI::Request" do
-      client.http.should be_an(HTTPI::Request)
-    end
+  before :all do
+    @server = IntegrationServer.run
   end
 
-  describe "#wsse" do
-    it "should return the Akami::WSSE object" do
-      client.wsse.should be_a(Akami::WSSE)
-    end
+  after :all do
+    @server.stop
   end
 
-  describe "#request" do
-    let(:request_builder) { stub_everything('request_builder') }
-    let(:response) { mock('response') }
-
-    before do
-      HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:authentication)))
-      HTTPI.stubs(:post).returns(new_response)
-
-      Savon::SOAP::RequestBuilder.stubs(:new).returns(request_builder)
-      request_builder.stubs(:request).returns(stub(:response => response))
-      response.stubs(:http).returns(new_response)
-    end
-
-    context "without any arguments" do
-      it "should raise an ArgumentError" do
-        lambda { client.request }.should raise_error(ArgumentError)
-      end
-    end
-
-    describe "setting dependencies of the request builder" do
-      it "sets the wsdl property with the client's WSDL document" do
-        request_builder.expects(:wsdl=).with(client.wsdl)
-        client.request(:get_user)
-      end
-
-      it "sets the http property with an HTTPI::Request object" do
-        request_builder.expects(:http=).with { |http| http.is_a?(HTTPI::Request) }
-        client.request(:get_user)
-      end
-
-      it "sets the wsse property with an Akami:WSSE object" do
-        request_builder.expects(:wsse=).with { |wsse| wsse.is_a?(Akami::WSSE) }
-        client.request(:get_user)
-      end
-
-      it "sets the config property with a Savon::Config object" do
-        request_builder.expects(:config=).with { |config| config.is_a?(Savon::Config) }
-        client.request(:get_user)
-      end
-    end
-
-    context "with a single argument" do
-      it "sets the operation of the request builder to the argument" do
-        expect_request_builder_to_receive(:get_user)
-        client.request(:get_user)
-      end
-    end
-
-    context "with a Symbol and a Hash" do
-      it "uses the hash to set attributes of the request builder" do
-        expect_request_builder_to_receive(:get_user, :attributes => { :active => true })
-        client.request(:get_user, :active => true)
-      end
-
-      it "uses the :soap_action key of the hash to set the SOAP action of the request builder" do
-        expect_request_builder_to_receive(:get_user, :soap_action => :test_action)
-        client.request(:get_user, :soap_action => :test_action)
-      end
-
-      it "uses the :body key of the hash to set the SOAP body of the request builder" do
-        expect_request_builder_to_receive(:get_user, :body => { :foo => "bar" })
-        client.request(:get_user, :body => { :foo => "bar" })
-      end
-    end
-
-    context "with two Symbols" do
-      it "uses the first symbol to set the namespace and the second symbol to set the operation of the request builder" do
-        expect_request_builder_to_receive(:get_user, :namespace_identifier => :v1)
-        client.request(:v1, :get_user)
-      end
-
-      it "should not set the target namespace if soap.namespace was set to nil in the post-configuration block" do
-        Savon::SOAP::RequestBuilder.unstub(:new)
-
-        namespace = 'xmlns:v1="http://v1_0.ws.auth.order.example.com/"'
-        HTTPI::Request.any_instance.expects(:body=).with { |value| !value.include?(namespace) }
-
-        client.request(:v1, :get_user) { soap.namespace = nil }
-      end
-    end
-
-    context "with two Symbols and a Hash" do
-      it "uses the first symbol to set the namespace and the second symbol to set the operation of the request builder" do
-        expect_request_builder_to_receive(:get_user, :namespace_identifier => :wsdl)
-        client.request(:wsdl, :get_user)
-      end
-
-      it "should use the hash to set the attributes of the request builder" do
-        expect_request_builder_to_receive(:get_user, :namespace_identifier => :wsdl, :attributes => { :active => true })
-        client.request(:wsdl, :get_user, :active => true)
-      end
-
-      it "should use the :soap_action key of the hash to set the SOAP action of the request builder" do
-        expect_request_builder_to_receive(:get_user, :namespace_identifier => :wsdl, :soap_action => :test_action)
-        client.request(:wsdl, :get_user, :soap_action => :test_action)
+  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
 
-      it "should use the :body key of the hash to set the SOAP body of the request builder" do
-        expect_request_builder_to_receive(:get_user, :namespace_identifier => :wsdl, :body => { :foo => "bar" })
-        client.request(:wsdl, :get_user, :body => { :foo => "bar" })
-      end
+      expect(client.globals[:wsdl]).to eq(Fixture.wsdl(:authentication))
     end
 
-    context "with a block" do
-      before do
-        Savon::SOAP::RequestBuilder.unstub(:new)
-      end
-
-      it "passes the block to the request builder" do
-        # this is painful. it would be trivial to test in > Ruby 1.9, but this is
-        # the only way I know how in < 1.9.
-        dummy = Object.new
-        dummy.instance_eval do
-          class << self; attr_accessor :request_builder, :block_given; end
-          def request
-            self.block_given = block_given?
-            request_builder.request
-          end
-
-          def method_missing(_, *args)
-          end
-        end
-
-        dummy.request_builder = request_builder
-        Savon::SOAP::RequestBuilder.stubs(:new).returns(dummy)
-
-        blk = lambda {}
-        client.request(:authenticate, &blk)
-
-        dummy.block_given.should == true
-      end
-
-      it "executes the block in the context of the request builder" do
-        Savon::SOAP::RequestBuilder.class_eval do
-          def who
-            self
-          end
-        end
-
-        client.request(:authenticate) { who.should be_a Savon::SOAP::RequestBuilder }
-      end
-
-      context "with a block expecting one argument" do
-        it "should yield the SOAP object" do
-          client.request(:authenticate) { |soap| soap.should be_a Savon::SOAP::XML }
-        end
-      end
-
-      context "with a block expecting two arguments" do
-        it "should yield the SOAP and WSDL objects" do
-          client.request(:authenticate) do |soap, wsdl|
-            soap.should be_a(Savon::SOAP::XML)
-            wsdl.should be_an(Wasabi::Document)
-          end
-        end
-      end
-
-      context "with a block expecting three arguments" do
-        it "should yield the SOAP, WSDL and HTTP objects" do
-          client.request(:authenticate) do |soap, wsdl, http|
-            soap.should be_a(Savon::SOAP::XML)
-            wsdl.should be_an(Wasabi::Document)
-            http.should be_an(HTTPI::Request)
-          end
-        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
 
-      context "with a block expecting four arguments" do
-        it "should yield the SOAP, WSDL, HTTP and WSSE objects" do
-          client.request(:authenticate) do |soap, wsdl, http, wsse|
-            soap.should be_a(Savon::SOAP::XML)
-            wsdl.should be_a(Wasabi::Document)
-            http.should be_an(HTTPI::Request)
-            wsse.should be_a(Akami::WSSE)
-          end
-        end
-      end
-
-      context "with a block expecting no arguments" do
-        it "should let you access the SOAP object" do
-          client.request(:authenticate) { soap.should be_a(Savon::SOAP::XML) }
-        end
-
-        it "should let you access the HTTP object" do
-          client.request(:authenticate) { http.should be_an(HTTPI::Request) }
-        end
-
-        it "should let you access the WSSE object" do
-          client.request(:authenticate) { wsse.should be_a(Akami::WSSE) }
-        end
-
-        it "should let you access the WSDL object" do
-          client.request(:authenticate) { wsdl.should be_a(Wasabi::Document) }
-        end
-      end
-    end
-
-    it "should not set the Cookie header for the next request" do
-      client.request :authenticate
-      client.http.headers["Cookie"].should be_nil
-    end
-  end
-
-  context "#request with a Set-Cookie response header" do
-    before do
-      HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:authentication)))
-      HTTPI.stubs(:post).returns(new_response(:headers => { "Set-Cookie" => "some-cookie=choc-chip; Path=/; HttpOnly" }))
+      expect(client.globals[:wsdl]).to eq(Fixture.wsdl(:authentication))
     end
 
-    it "sets the cookies for the next request" do
-      client.http.expects(:set_cookies).with(kind_of(HTTPI::Response))
-      client.request :authenticate
+    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
   end
 
-  context "with a remote WSDL document" do
-    let(:client) { Savon::Client.new { wsdl.document = Endpoint.wsdl } }
-    before { HTTPI.expects(:get).returns(new_response(:body => Fixture.wsdl(:authentication))) }
-
-    it "adds a SOAPAction header containing the SOAP action name" do
-      HTTPI.stubs(:post).returns(new_response)
-
-      client.request :authenticate do
-        http.headers["SOAPAction"].should == %{"authenticate"}
-      end
-    end
-
-    it "should execute SOAP requests and return the response" do
-      HTTPI.expects(:post).returns(new_response)
-      response = client.request(:authenticate)
-
-      response.should be_a(Savon::SOAP::Response)
-      response.to_xml.should == Fixture.response(:authentication)
+  describe "#globals" do
+    it "returns the current set of global options" do
+      expect(new_client.globals).to be_an_instance_of(Savon::GlobalOptions)
     end
   end
 
-  context "with a local WSDL document" do
-    let(:client) { Savon::Client.new { wsdl.document = "spec/fixtures/wsdl/authentication.xml" } }
-
-    before { HTTPI.expects(:get).never }
-
-    it "adds a SOAPAction header containing the SOAP action name" do
-      HTTPI.stubs(:post).returns(new_response)
-
-      client.request :authenticate do
-        http.headers["SOAPAction"].should == %{"authenticate"}
-      end
+  describe "#operations" do
+    it "returns all operation names" do
+      operations = new_client.operations
+      expect(operations).to eq([:authenticate])
     end
 
-    it "should execute SOAP requests and return the response" do
-      HTTPI.expects(:post).returns(new_response)
-      response = client.request(:authenticate)
-
-      response.should be_a(Savon::SOAP::Response)
-      response.to_xml.should == Fixture.response(:authentication)
+    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
 
-  context "when the WSDL specifies multiple namespaces" do
-    before do
-      HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:multiple_namespaces)))
-      HTTPI.stubs(:post).returns(new_response)
-    end
-
-    it "qualifies each element with the appropriate namespace" do
-      HTTPI::Request.any_instance.expects(:body=).with do |value|
-        xml = Nokogiri::XML(value)
-
-        title = xml.at_xpath(
-          ".//actions:Save/actions:article/article:Title/text()",
-          "article" => "http://example.com/article",
-          "actions" => "http://example.com/actions").to_s
-        author = xml.at_xpath(
-          ".//actions:Save/actions:article/article:Author/text()",
-          "article" => "http://example.com/article",
-          "actions" => "http://example.com/actions").to_s
-
-        title == "Hamlet" && author == "Shakespeare"
-      end
-
-      client.request :save do
-        soap.body = { :article => { "Title" => "Hamlet", "Author" => "Shakespeare" } }
-      end
-    end
-
-    it "still sends nil as xsi:nil as in the non-namespaced case" do
-      HTTPI::Request.any_instance.expects(:body=).with do |value|
-        xml = Nokogiri::XML(value)
-
-        attribute = xml.at_xpath(".//article:Title/@xsi:nil",
-          "xsi" => "http://www.w3.org/2001/XMLSchema-instance",
-          "article" => "http://example.com/article").to_s
-
-        attribute == "true"
-      end
-
-      client.request(:save) { soap.body = { :article => { "Title" => nil } } }
+  describe "#operation" do
+    it "returns a new SOAP operation" do
+      operation = new_client.operation(:authenticate)
+      expect(operation).to be_a(Savon::Operation)
     end
 
-    it "translates between symbol :save and string 'Save'" do
-      HTTPI::Request.any_instance.expects(:body=).with do |value|
-        xml = Nokogiri::XML(value)
-        !!xml.at_xpath(".//actions:Save", "actions" => "http://example.com/actions")
-      end
-
-      client.request :save do
-        soap.body = { :article => { :title => "Hamlet", :author => "Shakespeare" } }
-      end
+    it "raises if there's no such SOAP operation" do
+      expect { new_client.operation(:does_not_exist) }.
+        to raise_error(ArgumentError)
     end
 
-    it "qualifies Save with the appropriate namespace" do
-      HTTPI::Request.any_instance.expects(:body=).with do |value|
-        xml = Nokogiri::XML(value)
-        !!xml.at_xpath(".//actions:Save", "actions" => "http://example.com/actions")
-      end
-
-      client.request "Save" do
-        soap.body = { :article => { :title => "Hamlet", :author => "Shakespeare" } }
-      end
+    it "does not raise when there is no WSDL document" do
+      new_client_without_wsdl.operation(:does_not_exist)
     end
   end
 
-  context "when the WSDL has a lowerCamel name" do
-    before do
-      HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:lower_camel)))
-      HTTPI.stubs(:post).returns(new_response)
-    end
-
-    it "appends namespace when name is specified explicitly" do
-      HTTPI::Request.any_instance.expects(:body=).with do |value|
-        xml = Nokogiri::XML(value)
-        !!xml.at_xpath(".//actions:Save/actions:lowerCamel", "actions" => "http://example.com/actions")
-      end
-
-      client.request("Save") { soap.body = { 'lowerCamel' => 'theValue' } }
-    end
+  describe "#call" do
+    it "calls a new SOAP operation" do
+      locals = { :message => { :symbol => "AAPL" } }
+      soap_response = new_soap_response
 
-    it "still appends namespace when converting from symbol" do
-      HTTPI::Request.any_instance.expects(:body=).with do |value|
-        xml = Nokogiri::XML(value)
-        !!xml.at_xpath(".//actions:Save/actions:lowerCamel", "actions" => "http://example.com/actions")
-      end
+      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).returns(operation)
 
-      client.request("Save") { soap.body = { :lower_camel => 'theValue' } }
+      response = new_client.call(:authenticate, locals)
+      expect(response).to eq(soap_response)
     end
-  end
 
-  context "with multiple types" do
-    before do
-      HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:multiple_types)))
-      HTTPI.stubs(:post).returns(new_response)
-    end
+    it "sets the cookies for the next request" do
+      last_response = new_http_response(:headers => { "Set-Cookie" => "some-cookie=choc-chip; Path=/; HttpOnly" })
+      client = new_client
 
-    it "does not blow up" do
-      HTTPI::Request.any_instance.expects(:body=).with { |value| value.include?("Save") }
-      client.request(:save) { soap.body = {} }
-    end
-  end
+      HTTPI.stubs(:post).returns(last_response)
 
-  context "with an Array of namespaced items" do
-    context "with a single namespace" do
-      let(:client) { Savon::Client.new { wsdl.document = "spec/fixtures/wsdl/taxcloud.xml" } }
+      # does not try to set cookies for the first request
+      HTTPI::Request.any_instance.expects(:set_cookies).never
+      client.call(:authenticate)
 
-      before do
-        HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:taxcloud)))
-        HTTPI.stubs(:post).returns(new_response)
-      end
+      HTTPI.stubs(:post).returns(new_http_response)
 
-      it "should namespaces each Array item as expected" do
-        HTTPI::Request.any_instance.expects(:body=).with do |value|
-          xml = Nokogiri::XML(value)
-          !!xml.at_xpath(".//tc:cartItems/tc:CartItem/tc:ItemID", { "tc" => "http://taxcloud.net" })
-        end
-
-        address = { "Address1" => "888 6th Ave", "Address2" => nil, "City" => "New York", "State" => "NY", "Zip5" => "10001", "Zip4" => nil }
-        cart_item = { "Index" => 0, "ItemID" => "SKU-TEST", "TIC" => "00000", "Price" => 50.0, "Qty" => 1 }
-
-        client.request :lookup, :body => {
-          "customerID"  => 123,
-          "cartID"      => 456,
-          "cartItems"   => { "CartItem" => [cart_item] },
-          "origin"      => address,
-          "destination" => address
-        }
-      end
+      # sets cookies from the last response
+      HTTPI::Request.any_instance.expects(:set_cookies).with(last_response)
+      client.call(:authenticate)
     end
 
-    context "with multiple namespaces" do
-      let(:client) { Savon::Client.new { wsdl.document = "spec/fixtures/wsdl/multiple_namespaces.xml" } }
+    it "supports a block without arguments to call an operation with local options" do
+      client = new_client(:endpoint => @server.url(:repeat))
 
-      before do
-        HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:multiple_namespaces)))
-        HTTPI.stubs(:post).returns(new_response)
+      response = client.call(:authenticate) do
+        message(:symbol => "AAPL" )
       end
 
-      it "should namespace each Array item as expected" do
-        HTTPI::Request.any_instance.expects(:body=).with do |value|
-          xml = Nokogiri::XML(value)
-          namespaces = { "actions" => "http://example.com/actions", "article" => "http://example.com/article" }
-          !!xml.at_xpath(".//actions:Lookup/actions:articles/article:Article/article:Author", namespaces)
-        end
-
-        article = { "Author" => "John Smith", "Title" => "Modern SOAP" }
-        client.request :lookup, :body => {
-          "articles" => { "Article" => [article] }
-        }
-      end
-    end
-
-  end
-
-  context "without a WSDL document" do
-    let(:client) do
-      Savon::Client.new do
-        wsdl.endpoint = Endpoint.soap
-        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
-      end
+      expect(response.http.body).to include("<symbol>AAPL</symbol>")
     end
 
-    before { HTTPI.expects(:get).never }
-
-    it "raise an ArgumentError when trying to access the WSDL" do
-      lambda { client.wsdl.soap_actions }.should raise_error(ArgumentError, /Wasabi/)
-    end
+    it "supports a block with one argument to call an operation with local options" do
+      client = new_client(:endpoint => @server.url(:repeat))
 
-    it "adds a SOAPAction header containing the SOAP action name" do
-      HTTPI.stubs(:post).returns(new_response)
+      # supports instance variables!
+      @instance_variable = { :symbol => "AAPL" }
 
-      client.request :authenticate do
-        http.headers["SOAPAction"].should == %{"authenticate"}
+      response = client.call(:authenticate) do |locals|
+        locals.message(@instance_variable)
       end
-    end
-
-    it "should execute SOAP requests and return the response" do
-      HTTPI.expects(:post).returns(new_response)
-      response = client.request(:authenticate)
 
-      response.should be_a(Savon::SOAP::Response)
-      response.to_xml.should == Fixture.response(:authentication)
+      expect(response.http.body).to include("<symbol>AAPL</symbol>")
     end
-  end
 
-  context "when encountering a SOAP fault" do
-    let(:client) do
-      Savon::Client.new do
-        wsdl.endpoint = Endpoint.soap
-        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
-      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
+  end
 
-    before { HTTPI::expects(:post).returns(new_response(:code => 500, :body => Fixture.response(:soap_fault))) }
+  def new_http_response(options = {})
+    defaults = { :code => 200, :headers => {}, :body => Fixture.response(:authentication) }
+    response = defaults.merge options
 
-    it "should raise a Savon::SOAP::Fault" do
-      lambda { client.request :authenticate }.should raise_error(Savon::SOAP::Fault)
-    end
+    HTTPI::Response.new response[:code], response[:headers], response[:body]
   end
 
-  context "when encountering an HTTP error" do
-    let(:client) do
-      Savon::Client.new do
-        wsdl.endpoint = Endpoint.soap
-        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
-      end
-    end
-
-    before { HTTPI::expects(:post).returns(new_response(:code => 500)) }
+  def new_soap_response(options = {})
+    http = new_http_response(options)
+    globals = Savon::GlobalOptions.new
+    locals = Savon::LocalOptions.new
 
-    it "should raise a Savon::HTTP::Error" do
-      lambda { client.request :authenticate }.should raise_error(Savon::HTTP::Error)
-    end
+    Savon::Response.new(http, globals, locals)
   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]
+  def new_client(globals = {})
+    globals = { :wsdl => Fixture.wsdl(:authentication), :log => false }.merge(globals)
+    Savon.client(globals)
   end
 
-  def expect_request_builder_to_receive(operation, options = {})
-    Savon::SOAP::RequestBuilder.expects(:new).with(operation, options).returns(request_builder)
+  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