wash_out 0.10.0.beta.1 → 0.10.0

data/lib/wash_out/wsse.rb

@@ -1,26 +1,41 @@
 module WashOut
-  class Wsse
 
-    attr_reader :soap_config
+  module WsseParams
+    def wsse_username
+      if request.env['WSSE_TOKEN']
+        request.env['WSSE_TOKEN'].values_at(:username, :Username).compact.first
+      end
+    end
+  end
 
+  class Wsse
+    attr_reader :soap_config
     def self.authenticate(soap_config, token)
       wsse = self.new(soap_config, token)
 
       unless wsse.eligible?
-        raise WashOut::SOAPError, "Unauthorized"
+        raise WashOut::Dispatcher::SOAPError, "Unauthorized"
       end
     end
 
     def initialize(soap_config, token)
       @soap_config = soap_config
       if token.blank? && required?
-        raise WashOut::SOAPError, "Missing required UsernameToken"
+        raise WashOut::Dispatcher::SOAPError, "Missing required UsernameToken"
       end
       @username_token = token
     end
 
     def required?
-      !soap_config.wsse_username.blank?
+      !soap_config.wsse_username.blank? || auth_callback?
+    end
+
+    def auth_callback?
+      return !!soap_config.wsse_auth_callback && soap_config.wsse_auth_callback.respond_to?(:call) && soap_config.wsse_auth_callback.arity == 2
+    end
+
+    def perform_auth_callback(user, password)
+      soap_config.wsse_auth_callback.call(user, password)
     end
 
     def expected_user
@@ -34,8 +49,8 @@ module WashOut
     def matches_expected_digest?(password)
       nonce     = @username_token.values_at(:nonce, :Nonce).compact.first
       timestamp = @username_token.values_at(:created, :Created).compact.first
-
       return false if nonce.nil? || timestamp.nil?
+      timestamp = timestamp.to_datetime
 
       # Token should not be accepted if timestamp is older than 5 minutes ago
       # http://www.oasis-open.org/committees/download.php/16782/wss-v1.1-spec-os-UsernameTokenProfile.pdf
@@ -47,11 +62,11 @@ module WashOut
       flavors = Array.new
 
       # Ruby / Savon
-      token = nonce + timestamp.to_s + expected_password
+      token = nonce + timestamp.strftime("%Y-%m-%dT%H:%M:%SZ") + expected_password
       flavors << Base64.encode64(Digest::SHA1.hexdigest(token)).chomp!
 
       # Java
-      token = Base64.decode64(nonce) + timestamp.to_s + expected_password
+      token = Base64.decode64(nonce) + timestamp.strftime("%Y-%m-%dT%H:%M:%SZ") + expected_password
       flavors << Base64.encode64(Digest::SHA1.digest(token)).chomp!
 
       flavors.each do |f|
@@ -67,11 +82,15 @@ module WashOut
       user     = @username_token.values_at(:username, :Username).compact.first
       password = @username_token.values_at(:password, :Password).compact.first
 
-      if (expected_user == user && expected_password == password)
+      if (expected_user == user && matches_expected_digest?(password))
         return true
       end
 
-      if (expected_user == user && matches_expected_digest?(password))
+      if auth_callback?
+        return perform_auth_callback(user, password)
+      end
+
+      if (expected_user == user && expected_password == password)
         return true
       end
 

data/spec/dummy/config/environments/test.rb

@@ -26,4 +26,5 @@ Dummy::Application.configure do
 
   # Print deprecation notices to the stderr
   config.active_support.deprecation = :stderr
+  config.active_support.test_order = :random
 end

data/spec/lib/wash_out/dispatcher_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe WashOut::Rails::Controller do
+describe WashOut::Dispatcher do
 
   class Dispatcher < ApplicationController
     soap_service
@@ -13,19 +13,19 @@ describe WashOut::Rails::Controller do
   end
 
   it "finds nested hashes" do
-    WashOut::Middlewares::Router.deep_select(:foo => 1){|k,v| k == :foo}.should == [1]
-    WashOut::Middlewares::Router.deep_select({:foo => {:foo => 1}}){|k,v| k == :foo}.should == [{:foo => 1}, 1]
+    expect(WashOut::Dispatcher.deep_select(:foo => 1){|k,v| k == :foo}).to eq [1]
+    expect(WashOut::Dispatcher.deep_select({:foo => {:foo => 1}}){|k,v| k == :foo}).to eq([{:foo => 1}, 1])
   end
 
   it "replaces nested hashed" do
-    WashOut::Middlewares::Router.deep_replace_href({:foo => {:@href => 1}}, {1 => 2}).should == {:foo => 2}
-    WashOut::Middlewares::Router.deep_replace_href({:bar => {:foo => {:@href => 1}}}, {1 => 2}).should == {:bar => {:foo => 2}}
+    expect(WashOut::Dispatcher.deep_replace_href({:foo => {:@href => 1}}, {1 => 2})).to eq({:foo => 2})
+    expect(WashOut::Dispatcher.deep_replace_href({:bar => {:foo => {:@href => 1}}}, {1 => 2})).to eq({:bar => {:foo => 2}})
   end
 
   xit "parses typical request" do
     dispatcher = Dispatcher.mock("<foo>1</foo>")
     dispatcher._parse_soap_parameters
-    dispatcher.params.should == {:foo => "1"}
+    expect(dispatcher.params).to eq({:foo => "1"})
   end
 
   xit "parses href request" do
@@ -45,38 +45,53 @@ describe WashOut::Rails::Controller do
       </root>
     XML
     dispatcher._parse_soap_parameters
-    dispatcher.params[:root][:request][:entities].should == {
+    expect(dispatcher.params[:root][:request][:entities]).to eq({
       :foo => {:bar=>"1"},
       :sub => {:foo=>"1", :@id=>"id2"},
       :@id => "id1"
-    }
+    })
+  end
+
+  describe "#_map_soap_parameters" do
+    let(:dispatcher) { Dispatcher.new }
+    let(:soap_config) { WashOut::SoapConfig.new(camelize_wsdl: false) }
+
+    before do
+      allow(dispatcher).to receive(:action_spec).and_return(in: WashOut::Param.parse_def(soap_config, { foo: { "@bar" => :string, empty: :string } } ))
+      allow(dispatcher).to receive(:xml_data).and_return(foo: { "@bar" => "buzz", empty: { :"@xsi:type" => "xsd:string" } })
+    end
+
+    it "should handle empty strings that have been parsed wrong by nori, but preserve attrs" do
+      dispatcher._map_soap_parameters
+      expect(dispatcher.params).to eq("foo" => { "bar" => "buzz", "empty" => nil })
+    end
   end
 
   describe "#_load_params" do
     let(:dispatcher) { Dispatcher.new }
-    let(:soap_config) { OpenStruct.new(camelize_wsdl: false) }
+    let(:soap_config) { WashOut::SoapConfig.new({ camelize_wsdl: false }) }
     it "should load params for an array" do
       spec = WashOut::Param.parse_def(soap_config, {:my_array => [:integer] } )
       xml_data = {:my_array => [1, 2, 3]}
-      dispatcher._load_params(spec, xml_data).should == {"my_array" => [1, 2, 3]}
+      expect(dispatcher._load_params(spec, xml_data)).to eq({"my_array" => [1, 2, 3]})
     end
 
     it "should load params for an empty array" do
       spec = WashOut::Param.parse_def(soap_config, {:my_array => [:integer] } )
       xml_data = {}
-      dispatcher._load_params(spec, xml_data).should == {}
+      expect(dispatcher._load_params(spec, xml_data)).to eq({})
     end
 
     it "should load params for a nested array" do
       spec = WashOut::Param.parse_def(soap_config, {:nested => {:my_array => [:integer]}} )
       xml_data = {:nested => {:my_array => [1, 2, 3]}}
-      dispatcher._load_params(spec, xml_data).should == {"nested" => {"my_array" => [1, 2, 3]}}
+      expect(dispatcher._load_params(spec, xml_data)).to eq({"nested" => {"my_array" => [1, 2, 3]}})
     end
 
     it "should load params for an empty nested array" do
       spec = WashOut::Param.parse_def(soap_config, {:nested => {:empty => [:integer] }} )
       xml_data = {:nested => nil}
-      dispatcher._load_params(spec, xml_data).should == {"nested" => {}}
+      expect(dispatcher._load_params(spec, xml_data)).to eq({"nested" => {}})
     end
 
   end

data/spec/lib/wash_out/middleware_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'wash_out/middleware'
+require 'rexml/document'
+
+describe WashOut::Middleware do
+  it 'handles Rack environment variables' do
+    err = begin
+      REXML::Document.new '<hi>'
+    rescue REXML::ParseException => e
+      e
+    end
+
+    env = {}
+    expect {
+      WashOut::Middleware.raise_or_render_rexml_parse_error err, env
+    }.to raise_exception(REXML::ParseException)
+
+    env['HTTP_SOAPACTION'] = 'pretend_action'
+    env['rack.errors'] = double 'logger', {:puts => true} 
+    env['rack.input'] = double 'basic-rack-input', {:string => '<hi>'} 
+    result = WashOut::Middleware.raise_or_render_rexml_parse_error err, env
+    expect(result[0]).to eq 400
+    expect(result[1]['Content-Type']).to eq 'text/xml'
+    msg = result[2][0]
+    expect(msg).to include 'Error parsing SOAP Request XML'
+    expect(msg).to include 'soap:Fault'
+    expect(msg).not_to include __FILE__
+    
+    env['rack.input'] = double 'passenger-input', {:read => '<hi>'}
+    result = WashOut::Middleware.raise_or_render_rexml_parse_error err, env
+    expect(result[0]).to eq 400
+  end
+end

data/spec/lib/wash_out/param_spec.rb

@@ -18,47 +18,77 @@ describe WashOut::Param do
     end
 
     it "loads custom_types" do
-      soap_config = OpenStruct.new(camelize_wsdl: false)
+      soap_config = WashOut::SoapConfig.new({ camelize_wsdl: false })
       map = WashOut::Param.parse_def soap_config, Abraka2
 
-      map.should be_a_kind_of(Array)
-      map[0].name.should == 'value'
-      map[0].map[0].name.should == 'foo'
-      map[0].map[0].map[0].name.should == 'test'
+      expect(map).to be_a_kind_of(Array)
+      expect(map[0].name).to eq 'foo'
+      expect(map[0].map[0].name).to eq 'test'
     end
 
     it "respects camelization setting" do
-      soap_config = OpenStruct.new(camelize_wsdl: true)
+      soap_config = WashOut::SoapConfig.new({ camelize_wsdl: true })
 
       map = WashOut::Param.parse_def soap_config, Abraka2
 
-      map.should be_a_kind_of(Array)
-      map[0].name.should == 'Value'
-      map[0].map[0].name.should == 'Foo'
-      map[0].map[0].map[0].name.should == 'Test'
+      expect(map).to be_a_kind_of(Array)
+      expect(map[0].name).to eq 'Foo'
+      expect(map[0].map[0].name).to eq 'Test'
     end
   end
 
   it "should accept nested empty arrays" do
-    soap_config = OpenStruct.new(camelize_wsdl: false)
+    soap_config = WashOut::SoapConfig.new({ camelize_wsdl: false })
     map = WashOut::Param.parse_def(soap_config, {:nested => {:some_attr => :string, :empty => [:integer] }} )
-    map[0].load( {:nested => nil}, :nested).should == {}
+    expect(map[0].load( {:nested => nil}, :nested)).to eq({})
   end
 
   describe "booleans" do
-    let(:soap_config) { OpenStruct.new(camelize_wsdl: false) }
+    let(:soap_config) { WashOut::SoapConfig.new({ camelize_wsdl: false }) }
     # following http://www.w3.org/TR/xmlschema-2/#boolean, only true, false, 0 and 1 are allowed.
     # Nori maps the strings true and false to TrueClass and FalseClass, but not 0 and 1.
     let(:map) { WashOut::Param.parse_def(soap_config, :value => :boolean) }
 
     it "should accept 'true' and '1'" do
-      map[0].load({:value => true}, :value).should be_true
-      map[0].load({:value => "1"}, :value).should be_true
+      expect(map[0].load({:value => true}, :value)).to be true
+      expect(map[0].load({:value => "1"}, :value)).to be true
     end
 
     it "should accept 'false' and '0'" do
-      map[0].load({:value => false}, :value).should be_false
-      map[0].load({:value => "0"}, :value).should be_false
+      expect(map[0].load({:value => false}, :value)).to be false
+      expect(map[0].load({:value => "0"}, :value)).to be false
+    end
+  end
+
+  describe 'longs' do
+    let(:soap_config) { WashOut::SoapConfig.new({ camelize_wsdl: false }) }
+    let(:map) { WashOut::Param.parse_def(soap_config, :value => :long) }
+
+    it "should accept positive long" do
+      expect(map[0].load({:value => 9223372036854775807}, :value)).to eq 9223372036854775807
+    end
+
+    it "should accept negative long" do
+      expect(map[0].load({:value => -9223372036854775807}, :value)).to eq -9223372036854775807
+    end
+  end
+
+  describe '#flat_copy' do
+    it 'should copy everything' do
+      soap_config = WashOut::SoapConfig.new({})
+      type = :foo
+      multiplied = "of course"
+
+      param = WashOut::Param.new(soap_config, 'name', type, multiplied)
+      param.source_class = "middle class"
+      evil_clone = param.flat_copy
+
+      expect(evil_clone.source_class).to eq "middle class"
+      expect(evil_clone.name).to eq 'name'
+      expect(evil_clone.raw_name).to eq 'name'
+      expect(evil_clone.type).to eq "foo"
+      expect(evil_clone.multiplied).to eq "of course"
+      expect(evil_clone.soap_config).to eq soap_config
     end
   end
 end

data/spec/lib/wash_out/router_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'wash_out/router'
+
+describe WashOut::Router do
+  it 'returns a 200 with empty soap action' do
+
+    mock_controller do
+      # nothing
+    end
+
+    env = {}
+    env['REQUEST_METHOD'] = 'GET'
+    env['rack.input'] = double 'basic-rack-input', {:string => ''}
+    result = WashOut::Router.new('Api').call env
+
+    expect(result[0]).to eq(200)
+    #expect(result[1]['Content-Type']).to eq('text/xml')
+
+    msg = result[2][0]
+    expect(msg).to eq('OK')
+  end
+end

data/spec/lib/wash_out/type_spec.rb

@@ -1,4 +1,4 @@
-#encoding:utf-8
+  #encoding:utf-8
 
 require 'spec_helper'
 
@@ -15,11 +15,11 @@ describe WashOut::Type do
       map :foo => Abraka1
     end
 
-    Abraka1.wash_out_param_name.should == 'abraka1'
-    Abraka1.wash_out_param_map.should == {:test => :string}
+    expect(Abraka1.wash_out_param_name).to eq 'abraka1'
+    expect(Abraka1.wash_out_param_map).to eq({:test => :string})
 
-    Abraka2.wash_out_param_name.should == 'test'
-    Abraka2.wash_out_param_map.should == {:foo => Abraka1}
+    expect(Abraka2.wash_out_param_name).to eq 'test'
+    expect(Abraka2.wash_out_param_map).to eq({:foo => Abraka1})
   end
 
   it "allows arrays inside custom types" do
@@ -31,11 +31,11 @@ describe WashOut::Type do
       map :foo => [:bar => Abraka1]
     end
 
-    Abraka1.wash_out_param_name.should == 'abraka1'
-    Abraka1.wash_out_param_map.should == {:test => :string}
+    expect(Abraka1.wash_out_param_name).to eq 'abraka1'
+    expect(Abraka1.wash_out_param_map).to eq({:test => :string})
 
-    Abraka2.wash_out_param_name.should == 'test'
-    Abraka2.wash_out_param_map.should == {:foo => [:bar => Abraka1]}
+    expect(Abraka2.wash_out_param_name).to eq 'test'
+    expect(Abraka2.wash_out_param_map).to eq({:foo => [:bar => Abraka1]})
   end
 
 end

data/spec/lib/wash_out_spec.rb

@@ -28,19 +28,19 @@ describe WashOut do
 
   describe "Module" do
     it "includes" do
-      lambda {
+      expect {
         mock_controller do
           # nothing
         end
-      }.should_not raise_exception
+      }.not_to raise_exception
     end
 
     it "allows definition of a simple action" do
-      lambda {
+      expect {
         mock_controller do
           soap_action "answer", :args => nil, :return => :integer
         end
-      }.should_not raise_exception
+      }.not_to raise_exception
     end
   end
 
@@ -68,13 +68,13 @@ describe WashOut do
 
     it "lists operations" do
       operations = xml[:definitions][:binding][:operation]
-      operations.should be_a_kind_of(Array)
+      expect(operations).to be_a_kind_of(Array)
 
-      operations.map{|e| e[:'@name']}.sort.should == ['Result', 'getArea', 'rocky'].sort
+      expect(operations.map{|e| e[:'@name']}.sort).to eq ['Result', 'getArea', 'rocky'].sort
     end
 
     it "defines complex types" do
-      wsdl.include?('<xsd:complexType name="Circle1">').should == true
+      expect(wsdl.include?('<xsd:complexType name="Circle1">')).to be true
     end
 
     it "defines arrays" do
@@ -82,8 +82,8 @@ describe WashOut do
         find{|x| x[:'@name'] == 'Center'}[:sequence][:element].
         find{|x| x[:'@name'] == 'X'}
 
-      x[:'@min_occurs'].should == "0"
-      x[:'@max_occurs'].should == "unbounded"
+      expect(x[:'@min_occurs']).to eq "0"
+      expect(x[:'@max_occurs']).to eq "unbounded"
     end
   end
 
@@ -109,7 +109,7 @@ describe WashOut do
           </env:Envelope>
         XML
 
-        HTTPI.post("http://app/api/action", request).body.should == <<-XML
+        expect(HTTPI.post("http://app/api/action", request).body).to eq <<-XML
 <?xml version="1.0" encoding="UTF-8"?>
 <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false">
   <soap:Body>
@@ -129,8 +129,8 @@ describe WashOut do
           end
         end
 
-        savon(:answer)[:answer_response][:value].
-          should == "42"
+        expect(savon(:answer)[:answer_response][:value]).
+          to eq "42"
       end
 
       it "accept insufficient parameters" do
@@ -141,8 +141,8 @@ describe WashOut do
           end
         end
 
-        savon(:answer)[:answer_response][:value].
-          should == "42"
+        expect(savon(:answer)[:answer_response][:value]).
+          to eq "42"
       end
 
       it "accept empty parameter" do
@@ -152,8 +152,8 @@ describe WashOut do
             render :soap => {:a => params[:a]}
           end
         end
-        savon(:answer, :a => '')[:answer_response][:a].
-          should == {:"@xsi:type"=>"xsd:string"}
+        expect(savon(:answer, :a => '')[:answer_response][:a]).
+          to eq({:"@xsi:type"=>"xsd:string"})
       end
 
       it "accept one parameter" do
@@ -164,8 +164,8 @@ describe WashOut do
           end
         end
 
-        savon(:check_answer, 42)[:check_answer_response][:value].should == true
-        savon(:check_answer, 13)[:check_answer_response][:value].should == false
+        expect(savon(:check_answer, 42)[:check_answer_response][:value]).to be true
+        expect(savon(:check_answer, 13)[:check_answer_response][:value]).to be false
       end
 
       it "accept two parameters" do
@@ -176,7 +176,7 @@ describe WashOut do
           end
         end
 
-        savon(:funky, :a => 42, :b => 'k')[:funky_response][:value].should == '420k'
+        expect(savon(:funky, :a => 42, :b => 'k')[:funky_response][:value]).to eq '420k'
       end
     end
 
@@ -199,8 +199,8 @@ describe WashOut do
         message = { :circle => { :center => { :x => 3, :y => 4 },
                                  :radius => 5 } }
 
-        savon(:get_area, message)[:get_area_response].
-          should == ({ :area => (Math::PI * 25).to_s, :distance_from_o => (5.0).to_s })
+        expect(savon(:get_area, message)[:get_area_response]).
+          to eq ({ :area => (Math::PI * 25).to_s, :distance_from_o => (5.0).to_s })
       end
 
       it "accept arrays" do
@@ -211,7 +211,7 @@ describe WashOut do
                       },
                       :return => nil
           def rumba
-            params.should == {"rumbas" => [1, 2, 3]}
+            expect(params).to eq({"rumbas" => [1, 2, 3]})
             render :soap => nil
           end
         end
@@ -227,7 +227,7 @@ describe WashOut do
                       },
                       :return => nil
           def rumba
-            params.should == {}
+            expect(params).to eq({})
             render :soap => nil
           end
         end
@@ -242,7 +242,7 @@ describe WashOut do
                       },
                       :return => nil
           def rumba
-            params.should == {"nested" => {}}
+            expect(params).to eq({"nested" => {}})
             render :soap => nil
           end
         end
@@ -260,12 +260,12 @@ describe WashOut do
                       },
                       :return => nil
           def rumba
-            params.should == {
+            expect(params).to eq({
               "rumbas" => [
                 {"zombies" => 'suck', "puppies" => 'rock'},
                 {"zombies" => 'slow', "puppies" => 'fast'}
               ]
-            }
+            })
             render :soap => nil
           end
         end
@@ -292,8 +292,15 @@ describe WashOut do
           end
         end
 
-        savon(:gogogo)[:gogogo_response].
-          should == {:zoo=>"zoo", :boo=>{:moo=>"moo", :doo=>"doo", :"@xsi:type"=>"tns:Boo"}}
+        expect(savon(:gogogo)[:gogogo_response]).
+          to eq({
+            :zoo=>"zoo", 
+            :boo=>{
+              :moo=>"moo", 
+              :doo=>"doo", 
+              :"@xsi:type"=>"tns:Boo"
+            }
+          })
       end
 
       it "respond with arrays" do
@@ -306,7 +313,9 @@ describe WashOut do
           end
         end
 
-        savon(:rumba)[:rumba_response].should == {:value => ["1", "2", "3"]}
+        expect(savon(:rumba)[:rumba_response]).to eq({
+          :value => ["1", "2", "3"]
+        })
       end
 
       it "respond with complex structures inside arrays" do
@@ -314,55 +323,57 @@ describe WashOut do
           soap_action "rumba",
             :args   => nil,
             :return => {
-              :rumbas => [{:zombies => :string, :puppies => :string}]
+              :rumbas => [{:@level => :integer, :zombies => :string, :puppies => :string}]
             }
           def rumba
             render :soap =>
               {:rumbas => [
-                  {:zombies => "suck1", :puppies => "rock1" },
+                  {:@level => 80, :zombies => "suck1", :puppies => "rock1" },
                   {:zombies => "suck2", :puppies => "rock2" }
                 ]
               }
           end
         end
 
-        savon(:rumba)[:rumba_response].should == {
+        expect(savon(:rumba)[:rumba_response]).to eq({
           :rumbas => [
-            {:zombies => "suck1",:puppies => "rock1", :"@xsi:type"=>"tns:Rumbas"},
+            {:zombies => "suck1",:puppies => "rock1", :"@xsi:type"=>"tns:Rumbas", :@level => "80"},
             {:zombies => "suck2", :puppies => "rock2", :"@xsi:type"=>"tns:Rumbas" }
           ]
-        }
+        })
       end
 
       it "respond with structs in structs in arrays" do
         mock_controller do
           soap_action "rumba",
             :args => nil,
-            :return => [{:rumbas => {:zombies => :integer}}]
+            :return => [{:rumbas => {:@level => :integer, :zombies => :integer}}]
 
           def rumba
-            render :soap => [{:rumbas => {:zombies => 100000}}, {:rumbas => {:zombies => 2}}]
+            render :soap => [{:rumbas => {:@level => 80, :zombies => 100000}}, {:rumbas => {:@level => 90, :zombies => 2}}]
           end
         end
 
-        savon(:rumba)[:rumba_response].should == {
+        expect(savon(:rumba)[:rumba_response]).to eq({
           :value => [
             {
               :rumbas => {
                 :zombies => "100000",
-                :"@xsi:type" => "tns:Rumbas"
+                :"@xsi:type" => "tns:Rumbas",
+                :"@level" => "80"
               },
               :"@xsi:type" => "tns:Value"
             },
             {
               :rumbas => {
                 :zombies => "2",
-                :"@xsi:type" => "tns:Rumbas"
+                :"@xsi:type" => "tns:Rumbas",
+                :@level => "90",
               },
               :"@xsi:type"=>"tns:Value"
             }
           ]
-        }
+        })
       end
 
       context "with arrays missing" do
@@ -375,7 +386,7 @@ describe WashOut do
             end
           end
 
-          savon(:rocknroll)[:rocknroll_response].should be_nil
+          expect(savon(:rocknroll)[:rocknroll_response]).to be nil
         end
 
         it "respond with complext definition" do
@@ -387,7 +398,7 @@ describe WashOut do
             end
           end
 
-          savon(:rocknroll)[:rocknroll_response].should be_nil
+          expect(savon(:rocknroll)[:rocknroll_response]).to be nil
         end
 
         it "respond with nested simple definition" do
@@ -399,8 +410,10 @@ describe WashOut do
             end
           end
 
-          savon(:rocknroll)[:rocknroll_response][:my_value].
-            should == { :"@xsi:type" => "tns:MyValue" }
+          expect(savon(:rocknroll)[:rocknroll_response][:my_value]).
+            to eq({ 
+              :"@xsi:type" => "tns:MyValue"
+            })
         end
 
         it "handles incomplete array response" do
@@ -422,13 +435,13 @@ describe WashOut do
         mock_controller do
           soap_action "true", :args => :boolean, :return => :nil
           def true
-            params[:value].should == true
+            expect(params[:value]).to be true
             render :soap => nil
           end
 
           soap_action "false", :args => :boolean, :return => :nil
           def false
-            params[:value].should == false
+            expect(params[:value]).to be false
             render :soap => nil
           end
         end
@@ -443,26 +456,26 @@ describe WashOut do
         mock_controller do
           soap_action "date", :args => :date, :return => :nil
           def date
-            params[:value].should == Date.parse('2000-12-30') unless params[:value].blank?
+            expect(params[:value]).to eq Date.parse('2000-12-30') unless params[:value].blank?
             render :soap => nil
           end
         end
 
         savon(:date, :value => '2000-12-30')
-        lambda { savon(:date) }.should_not raise_exception
+        expect { savon(:date) }.not_to raise_exception
       end
 
       it "recognize base64Binary" do
         mock_controller do
           soap_action "base64", :args => :base64Binary, :return => :nil
           def base64
-            params[:value].should == 'test' unless params[:value].blank?
+            expect(params[:value]).to eq('test') unless params[:value].blank?
             render :soap => nil
           end
         end
 
         savon(:base64, :value => Base64.encode64('test'))
-        lambda { savon(:base64) }.should_not raise_exception
+        expect { savon(:base64) }.not_to raise_exception
       end
     end
 
@@ -477,9 +490,9 @@ describe WashOut do
           end
         end
 
-        lambda {
+        expect {
           savon(:duty, :bad => 42, :good => nil)
-        }.should raise_exception(Savon::SOAPFault)
+        }.to raise_exception(Savon::SOAPFault)
       end
 
       it "raise for date in incorrect format" do
@@ -489,22 +502,22 @@ describe WashOut do
             render :soap => nil
           end
         end
-        lambda {
+        expect {
           savon(:date, :value  => 'incorrect format')
-        }.should raise_exception(Savon::SOAPFault)
+        }.to raise_exception(Savon::SOAPFault)
       end
 
       it "raise to report SOAP errors" do
         mock_controller do
           soap_action "error", :args => { :need_error => :boolean }, :return => nil
           def error
-            raise WashOut::SOAPError.new("you wanted one") if params[:need_error]
+            raise self.class.const_get(:SOAPError), "you wanted one" if params[:need_error]
             render :soap => nil
           end
         end
 
-        lambda { savon(:error, :need_error => false) }.should_not raise_exception
-        lambda { savon(:error, :need_error => true) }.should raise_exception(Savon::SOAPFault)
+        expect { savon(:error, :need_error => false) }.not_to raise_exception
+        expect { savon(:error, :need_error => true) }.to raise_exception(Savon::SOAPFault)
       end
 
       it "misses basic exceptions" do
@@ -516,8 +529,8 @@ describe WashOut do
           end
         end
 
-        lambda { savon(:error, :need_error => false) }.should_not raise_exception
-        lambda { savon(:error, :need_error => true) }.should raise_exception(Exception)
+        expect { savon(:error, :need_error => false) }.not_to raise_exception
+        expect { savon(:error, :need_error => true) }.to raise_exception(Exception)
       end
 
       it "raise for manual throws" do
@@ -528,7 +541,7 @@ describe WashOut do
           end
         end
 
-        lambda { savon(:error) }.should raise_exception(Savon::SOAPFault)
+        expect { savon(:error) }.to raise_exception(Savon::SOAPFault)
       end
 
       it "raise when response structure mismatches" do
@@ -561,24 +574,27 @@ describe WashOut do
           end
         end
 
-        lambda { savon(:bad) }.should raise_exception(
-          WashOut::ProgrammerError,
+        expect { savon(:bad) }.to raise_exception(
+          WashOut::Dispatcher::ProgrammerError,
           /SOAP response .*wyldness.*Array.*Hash.*stallion/
         )
 
-        lambda { savon(:bad2) }.should raise_exception(
-          WashOut::ProgrammerError,
+        expect { savon(:bad2) }.to raise_exception(
+          WashOut::Dispatcher::ProgrammerError,
           /SOAP response .*oops.*String.*telephone_booths.*Array/
         )
       end
     end
 
     context "deprecates" do
-      it "old syntax" do
+      # This test uses deprecated rspec expectations
+      # and it's not clear how to rewrite it.
+      xit "old syntax" do
         # save rspec context check
         raise_runtime_exception = raise_exception(RuntimeError)
 
         mock_controller do
+
           lambda {
             soap_action "rumba",
                         :args   => :integer,
@@ -601,8 +617,7 @@ describe WashOut do
         end
       end
 
-      savon(name.underscore.to_sym)["#{name.underscore}_response".to_sym][:value].
-        should == "forty two"
+      expect(savon(name.underscore.to_sym)["#{name.underscore}_response".to_sym][:value]).to eq "forty two"
     end
 
     it "respects :response_tag option" do
@@ -613,14 +628,14 @@ describe WashOut do
         end
       end
 
-      savon(:specific).should == {:test => {:value=>"test"}}
+      expect(savon(:specific)).to eq({:test => {:value=>"test"}})
     end
 
     it "handles snakecase option properly" do
       mock_controller(snakecase_input: false, camelize_wsdl: false) do
         soap_action "rocknroll", :args => {:ZOMG => :string}, :return => nil
         def rocknroll
-          params["ZOMG"].should == "yam!"
+          expect(params["ZOMG"]).to eq "yam!"
           render :soap => nil
         end
       end
@@ -636,8 +651,8 @@ describe WashOut do
       mock_controller(wsse_username: "gorilla", wsse_password: "secret") do
         soap_action "checkToken", :args => :integer, :return => nil, :to => 'check_token'
         def check_token
-          request.env['WSSE_TOKEN']['username'].should == "gorilla"
-          request.env['WSSE_TOKEN']['password'].should == "secret"
+          expect(request.env['WSSE_TOKEN']['username']).to eq "gorilla"
+          expect(request.env['WSSE_TOKEN']['password']).to eq "secret"
           render :soap => nil
         end
       end
@@ -656,20 +671,20 @@ describe WashOut do
       end
 
       # correct auth
-      lambda { savon(:check_auth, 42){ wsse_auth "gorilla", "secret" } }.
-        should_not raise_exception
+      expect { savon(:check_auth, 42){ wsse_auth "gorilla", "secret" } }.
+        not_to raise_exception
 
       # wrong user
-      lambda { savon(:check_auth, 42){ wsse_auth "chimpanzee", "secret" } }.
-        should raise_exception(Savon::SOAPFault)
+      expect { savon(:check_auth, 42){ wsse_auth "chimpanzee", "secret" } }.
+        to raise_exception(Savon::SOAPFault)
 
       # wrong pass
-      lambda { savon(:check_auth, 42){ wsse_auth "gorilla", "nicetry" } }.
-        should raise_exception(Savon::SOAPFault)
+      expect { savon(:check_auth, 42){ wsse_auth "gorilla", "nicetry" } }.
+        to raise_exception(Savon::SOAPFault)
 
       # no auth
-      lambda { savon(:check_auth, 42) }.
-        should raise_exception(Savon::SOAPFault)
+      expect { savon(:check_auth, 42) }.
+        to raise_exception(Savon::SOAPFault)
     end
 
     it "handles PasswordDigest auth" do
@@ -681,20 +696,57 @@ describe WashOut do
       end
 
       # correct auth
-      lambda { savon(:check_auth, 42){ wsse_auth "gorilla", "secret", :digest } }.
-        should_not raise_exception
+      expect { savon(:check_auth, 42){ wsse_auth "gorilla", "secret" } }.
+        not_to raise_exception
+
+      # correct digest auth
+      expect { savon(:check_auth, 42){ wsse_auth "gorilla", "secret", :digest } }.
+        not_to raise_exception
+
+      # wrong user
+      expect { savon(:check_auth, 42){ wsse_auth "chimpanzee", "secret", :digest } }.
+        to raise_exception(Savon::SOAPFault)
+
+      # wrong pass
+      expect { savon(:check_auth, 42){ wsse_auth "gorilla", "nicetry", :digest } }.
+        to raise_exception(Savon::SOAPFault)
+
+      # no auth
+      expect { savon(:check_auth, 42) }.
+        to raise_exception(Savon::SOAPFault)
+    end
+
+    it "handles auth callback" do
+      mock_controller(
+        wsse_auth_callback: lambda {|user, password|
+          return user == "gorilla" && password == "secret" 
+        }
+      ) do
+        soap_action "checkAuth", :args => :integer, :return => :boolean, :to => 'check_auth'
+        def check_auth
+          render :soap => (params[:value] == 42)
+        end
+      end
+
+      # correct auth
+      expect { savon(:check_auth, 42){ wsse_auth "gorilla", "secret" } }.
+        not_to raise_exception
+
+      # correct digest auth
+      expect { savon(:check_auth, 42){ wsse_auth "gorilla", "secret", :digest } }.
+        to raise_exception(Savon::SOAPFault)
 
       # wrong user
-      lambda { savon(:check_auth, 42){ wsse_auth "chimpanzee", "secret", :digest } }.
-        should raise_exception(Savon::SOAPFault)
+      expect { savon(:check_auth, 42){ wsse_auth "chimpanzee", "secret", :digest } }.
+        to raise_exception(Savon::SOAPFault)
 
       # wrong pass
-      lambda { savon(:check_auth, 42){ wsse_auth "gorilla", "nicetry", :digest } }.
-        should raise_exception(Savon::SOAPFault)
+      expect { savon(:check_auth, 42){ wsse_auth "gorilla", "nicetry", :digest } }.
+        to raise_exception(Savon::SOAPFault)
 
       # no auth
-      lambda { savon(:check_auth, 42) }.
-        should raise_exception(Savon::SOAPFault)
+      expect { savon(:check_auth, 42) }.
+        to raise_exception(Savon::SOAPFault)
     end
 
   end