wash_out 0.9.0 → 0.12.0

data/spec/lib/wash_out_spec.rb

@@ -2,6 +2,29 @@
 
 require 'spec_helper'
 
+SIMPLE_REQUEST_XML = <<-SIMPLE_REQUEST_XML_HEREDOC
+<?xml version="1.0" encoding="UTF-8"?>
+<env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+  <env:Body>
+    <tns:answer>
+      <value>42</value>
+    </tns:answer>
+  </env:Body>
+</env:Envelope>
+SIMPLE_REQUEST_XML_HEREDOC
+
+SIMPLE_RESPONSE_XML = <<-SIMPLE_RESPONSE_XML_HEREDOC
+<?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>
+    <tns:answerResponse>
+      <Value xsi:type="xsd:int">42</Value>
+    </tns:answerResponse>
+  </soap:Body>
+</soap:Envelope>
+SIMPLE_RESPONSE_XML_HEREDOC
+
+
 describe WashOut do
 
   let :nori do
@@ -12,35 +35,37 @@ describe WashOut do
     )
   end
 
-  def savon(method, message={}, &block)
+  def savon(method, message={}, hashify=true, &block)
     message = {:value => message} unless message.is_a?(Hash)
 
-    savon = Savon::Client.new(:log => false, :wsdl => 'http://app/api/wsdl', &block)
-    savon.call(method, :message => message).to_hash
+    savon  = Savon::Client.new(:log => false, :wsdl => 'http://app/route/api/wsdl', &block)
+    result = savon.call(method, :message => message)
+    result = result.to_hash if hashify
+    result
   end
 
   def savon!(method, message={}, &block)
     message = {:value => message} unless message.is_a?(Hash)
 
-    savon = Savon::Client.new(:log => true, :wsdl => 'http://app/api/wsdl', &block)
+    savon = Savon::Client.new(:log => true, :wsdl => 'http://app/route/api/wsdl', &block)
     savon.call(method, :message => message).to_hash
   end
 
   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
 
@@ -59,7 +84,7 @@ describe WashOut do
                              :return => { :circle2 => { :y => :integer } }
       end
 
-      HTTPI.get("http://app/api/wsdl").body
+      HTTPI.get("http://app/route/api/wsdl").body
     end
 
     let :xml do
@@ -68,13 +93,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 +107,15 @@ 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"
+      expect(x[:'@nillable']).to eq "true"
+    end
+
+    it "adds nillable to all type definitions" do
+      types = xml[:definitions][:message].map { |d| d[:part] }.compact
+      nillable = types.map { |t| t[:"@xsi:nillable"] }
+      expect(nillable.all? { |v| v == "true" }).to be true
     end
   end
 
@@ -109,7 +141,7 @@ describe WashOut do
           </env:Envelope>
         XML
 
-        HTTPI.post("http://app/api/action", request).body.should == <<-XML
+        expect(HTTPI.post("http://app/route/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>
@@ -121,6 +153,56 @@ describe WashOut do
         XML
       end
 
+      it "accepts requests with no HTTP header with alias" do
+        mock_controller do
+          soap_action "answer", :as => 'whatever', :args => nil, :return => :int
+          def answer
+            render :soap => "42"
+          end
+        end
+
+        request = <<-XML
+          <?xml version="1.0" encoding="UTF-8"?>
+          <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Body>
+            <tns:whatever>
+              <value>42</value>
+            </tns:whatever>
+          </env:Body>
+          </env:Envelope>
+        XML
+
+        expect(HTTPI.post("http://app/route/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>
+    <tns:whateverResponse>
+      <Value xsi:type="xsd:int">42</Value>
+    </tns:whateverResponse>
+  </soap:Body>
+</soap:Envelope>
+        XML
+      end
+
+      it "succeeds when protect_from_forgery is enabled" do
+
+        # Enable allow_forgery_protection (affects all subsequent specs)
+        # Alternatively, assign in spec/dummy/config/environments/test.rb
+        Rails.application.config.after_initialize do
+          ActionController::Base.allow_forgery_protection = true
+        end
+
+        mock_controller do
+          soap_action "answer", :args => nil, :return => :int
+          def answer
+            render :soap => "42"
+          end
+        end
+
+        expect(HTTPI.post("http://app/route/api/action", SIMPLE_REQUEST_XML).body).to eq SIMPLE_RESPONSE_XML
+
+      end
+
       it "accept no parameters" do
         mock_controller do
           soap_action "answer", :args => nil, :return => :int
@@ -129,8 +211,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 +223,19 @@ describe WashOut do
           end
         end
 
-        savon(:answer)[:answer_response][:value].
-          should == "42"
+        expect(savon(:answer)[:answer_response][:value]).
+          to eq "42"
+      end
+
+      it "shows date in correct format" do
+        mock_controller do
+          soap_action "answer", :args => {}, :return => {:a => :date}
+          def answer
+            render :soap => {:a => DateTime.new(2000, 1, 1)}
+          end
+        end
+        result = Hash.from_xml savon(:answer, {}, false).http.body
+        expect(result['Envelope']['Body']['answerResponse']['A']).to eq '2000-01-01T00:00:00+00:00'
       end
 
       it "accept empty parameter" do
@@ -152,8 +245,7 @@ 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 be_nil
       end
 
       it "accept one parameter" do
@@ -164,8 +256,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 +268,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 +291,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 +303,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 +319,7 @@ describe WashOut do
                       },
                       :return => nil
           def rumba
-            params.should == {}
+            expect(params).to eq({})
             render :soap => nil
           end
         end
@@ -242,7 +334,7 @@ describe WashOut do
                       },
                       :return => nil
           def rumba
-            params.should == {"nested" => {}}
+            expect(params).to eq({"nested" => {}})
             render :soap => nil
           end
         end
@@ -260,12 +352,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 +384,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 +405,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 +415,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 +478,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 +490,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 +502,20 @@ describe WashOut do
             end
           end
 
-          savon(:rocknroll)[:rocknroll_response][:my_value].
-            should == { :"@xsi:type" => "tns:MyValue" }
+          expect(savon(:rocknroll)[:rocknroll_response][:my_value]).to be_nil
+        end
+
+        it "responds with missing parameters" do
+          mock_controller do
+            soap_action "rocknroll",
+              args: nil,
+              return: {my_value: :integer}
+            def rocknroll
+              render soap: {my_value: nil}
+            end
+          end
+
+          expect(savon(:rocknroll)[:rocknroll_response][:my_value]).to be_nil
         end
 
         it "handles incomplete array response" do
@@ -417,18 +532,187 @@ describe WashOut do
       end
     end
 
+    context "SOAP header" do
+      it "accepts requests with a simple header" do
+        mock_controller do
+          soap_action "answer", :args => nil, :return => :int, :header_args => :string
+          def answer
+            render :soap => "42"
+          end
+        end
+
+        request = <<-XML
+          <?xml version="1.0" encoding="UTF-8"?>
+          <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Header>
+              <tns:Auth>
+                <value>12345</value>
+              </tns:Auth>
+          </env:Header>
+          <env:Body>
+            <tns:answer>
+              <value>42</value>
+            </tns:answer>
+          </env:Body>
+          </env:Envelope>
+        XML
+
+        expect(HTTPI.post("http://app/route/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>
+    <tns:answerResponse>
+      <Value xsi:type="xsd:int">42</Value>
+    </tns:answerResponse>
+  </soap:Body>
+</soap:Envelope>
+        XML
+      end
+
+      it "makes simple header values accessible" do
+        mock_controller do
+          soap_action "answer", :args => nil, :return => :int
+          def answer
+            expect(soap_request.headers).to eq({value: "12345"})
+            render :soap => "42"
+          end
+        end
+
+        request = <<-XML
+          <?xml version="1.0" encoding="UTF-8"?>
+          <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Header>
+            <value>12345</value>
+          </env:Header>
+          <env:Body>
+            <tns:answer>
+              <value>42</value>
+            </tns:answer>
+          </env:Body>
+          </env:Envelope>
+        XML
+
+        HTTPI.post("http://app/route/api/action", request)
+
+      end
+
+      it "makes complex header values accessible" do
+        mock_controller do
+          soap_action "answer", :args => nil, :return => :int
+          def answer
+            expect(soap_request.headers[:auth][:answer_response]).to eq "12345"
+            render :soap => "42"
+          end
+        end
+
+        request = <<-XML
+          <?xml version="1.0" encoding="UTF-8"?>
+          <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Header>
+            <Auth>
+              <AnswerResponse>12345</AnswerResponse>
+            </Auth>
+          </env:Header>
+          <env:Body>
+            <tns:answer>
+              <value>42</value>
+            </tns:answer>
+          </env:Body>
+          </env:Envelope>
+        XML
+
+        HTTPI.post("http://app/route/api/action", request)
+
+      end
+
+      it "renders a simple header if specified" do
+        mock_controller do
+          soap_action "answer", :args => nil, :return => :int, header_return: :string
+          def answer
+            render :soap => "42", :header => "12345"
+          end
+        end
+
+
+        request = <<-XML
+          <?xml version="1.0" encoding="UTF-8"?>
+          <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Body>
+            <tns:answer>
+              <value>42</value>
+            </tns:answer>
+          </env:Body>
+          </env:Envelope>
+        XML
+
+        expect(HTTPI.post("http://app/route/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:Header>
+    <tns:answerResponse>
+      <Value xsi:type="xsd:string">12345</Value>
+    </tns:answerResponse>
+  </soap:Header>
+  <soap:Body>
+    <tns:answerResponse>
+      <Value xsi:type="xsd:int">42</Value>
+    </tns:answerResponse>
+  </soap:Body>
+</soap:Envelope>
+        XML
+      end
+    end
+
+    it "renders a complex header if specified" do
+      mock_controller do
+        soap_action "answer", :args => nil, :return => :int, header_return: {:"Auth" => :string}
+        def answer
+          render :soap => "42", :header => {Auth: "12345"}
+        end
+      end
+
+
+      request = <<-XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Body>
+          <tns:answer>
+            <value>42</value>
+          </tns:answer>
+        </env:Body>
+        </env:Envelope>
+      XML
+
+      expect(HTTPI.post("http://app/route/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:Header>
+    <tns:answerResponse>
+      <Auth xsi:type="xsd:string">12345</Auth>
+    </tns:answerResponse>
+  </soap:Header>
+  <soap:Body>
+    <tns:answerResponse>
+      <Value xsi:type="xsd:int">42</Value>
+    </tns:answerResponse>
+  </soap:Body>
+</soap:Envelope>
+        XML
+    end
+
+
     context "types" do
       it "recognize boolean" 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 +727,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 +761,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,9 +773,9 @@ 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
@@ -503,8 +787,21 @@ describe WashOut do
           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
+        mock_controller do
+          soap_action "error", :args => { :need_error => :boolean }, :return => nil
+          def error
+            raise self.class.const_get(:Exception), "you wanted one" if params[:need_error]
+            render :soap => nil
+          end
+        end
+
+        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
@@ -515,7 +812,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
@@ -548,12 +845,12 @@ describe WashOut do
           end
         end
 
-        lambda { savon(:bad) }.should raise_exception(
+        expect { savon(:bad) }.to raise_exception(
           WashOut::Dispatcher::ProgrammerError,
           /SOAP response .*wyldness.*Array.*Hash.*stallion/
         )
 
-        lambda { savon(:bad2) }.should raise_exception(
+        expect { savon(:bad2) }.to raise_exception(
           WashOut::Dispatcher::ProgrammerError,
           /SOAP response .*oops.*String.*telephone_booths.*Array/
         )
@@ -561,11 +858,14 @@ describe WashOut do
     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,
@@ -588,8 +888,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
@@ -600,31 +899,45 @@ 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
 
       savon(:rocknroll, "ZOMG" => 'yam!')
     end
+  end
+
+  describe "Router" do
+    it "raises when SOAP message without SOAP Envelope arrives" do
+      mock_controller do; end
+      invalid_request = '<a></a>'
+      response_hash = Nori.new.parse(HTTPI.post("http://app/route/api/action", invalid_request).body)
+      expect(response_hash["soap:Envelope"]["soap:Body"]["soap:Fault"]['faultstring']).to eq "Invalid SOAP request"
+    end
 
+    it "raises when SOAP message without SOAP Body arrives" do
+      mock_controller do; end
+      invalid_request = '<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"></s:Envelope>'
+      response_hash = Nori.new.parse(HTTPI.post("http://app/route/api/action", invalid_request).body)
+      expect(response_hash["soap:Envelope"]["soap:Body"]["soap:Fault"]['faultstring']).to eq "Invalid SOAP request"
+    end
   end
 
   describe "WS Security" do
-
     it "appends username_token to params" 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
@@ -643,20 +956,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
@@ -668,20 +981,59 @@ 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, nonce, timestamp|
+          authenticated = nonce ? WashOut::Wsse.matches_expected_digest?("secret", password, nonce, timestamp) : password == "secret"
+
+          return user == "gorilla" && authenticated
+        }
+      ) 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 } }.
+        not_to raise_exception
 
       # 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