wash_out 0.9.2 → 0.11.0.beta.1

data/lib/wash_out/dispatcher.rb

@@ -16,9 +16,8 @@ module WashOut
     class ProgrammerError < Exception; end
 
     def _authenticate_wsse
-
       begin
-        xml_security   = env['wash_out.soap_data'].values_at(:envelope, :Envelope).compact.first
+        xml_security   = request.env['wash_out.soap_data'].values_at(:envelope, :Envelope).compact.first
         xml_security   = xml_security.values_at(:header, :Header).compact.first
         xml_security   = xml_security.values_at(:security, :Security).compact.first
         username_token = xml_security.values_at(:username_token, :UsernameToken).compact.first
@@ -32,22 +31,27 @@ module WashOut
     end
 
     def _map_soap_parameters
-      strip_empty_nodes = lambda{|hash|
-        hash.keys.each do |key|
-          if hash[key].is_a? Hash
-            value = hash[key].delete_if{|k, v| k.to_s[0] == '@'}
+      @_params = _load_params action_spec[:in],
+        _strip_empty_nodes(action_spec[:in], xml_data)
+    end
 
-            if value.length > 0
-              hash[key] = strip_empty_nodes.call(value)
-            else
-              hash[key] = nil
-            end
-          end
+    def _strip_empty_nodes(params, hash)
+      hash.keys.each do |key|
+        param = params.detect { |a| a.raw_name.to_s == key.to_s }
+        next if !(param && hash[key].is_a?(Hash))
+
+        value = hash[key].delete_if do |k, _|
+          k.to_s[0] == '@' && !param.map.detect { |a| a.raw_name.to_s == k.to_s }
         end
 
-        hash
-      }
-      @_params = _load_params(action_spec[:in], strip_empty_nodes.call(xml_data))
+        if value.length > 0
+          hash[key] = _strip_empty_nodes param.map, value
+        else
+          hash[key] = nil
+        end
+      end
+
+      hash
     end
 
     # Creates the final parameter hash based on the request spec and xml_data from the request
@@ -64,12 +68,11 @@ module WashOut
 
     # This action generates the WSDL for defined SOAP methods.
     def _generate_wsdl
-
       @map       = self.class.soap_actions
       @namespace = soap_config.namespace
-      @name      = controller_path.gsub('/', '_')
+      @name      = controller_path
 
-      render :template => "wash_with_soap/#{soap_config.wsdl_style}/wsdl", :layout => false,
+      render :template => "wash_out/#{soap_config.wsdl_style}/wsdl", :layout => false,
              :content_type => 'text/xml'
     end
 
@@ -124,7 +127,7 @@ module WashOut
         return result_spec
       }
 
-      render :template => "wash_with_soap/#{soap_config.wsdl_style}/response",
+      render :template => "wash_out/#{soap_config.wsdl_style}/response",
              :layout => false,
              :locals => { :result => inject.call(result, @action_spec[:out]) },
              :content_type => 'text/xml'
@@ -135,6 +138,10 @@ module WashOut
       render_soap_error("Cannot find SOAP action mapping for #{request.env['wash_out.soap_action']}")
     end
 
+    def _invalid_request
+      render_soap_error("Invalid SOAP request")
+    end
+
     def _catch_soap_errors
       yield
     rescue SOAPError => error
@@ -146,56 +153,79 @@ module WashOut
     # Rails do not support sequental rescue_from handling, that is, rescuing an
     # exception from a rescue_from handler. Hence this function is a public API.
     def render_soap_error(message, code=nil)
-      render :template => "wash_with_soap/#{soap_config.wsdl_style}/error", :status => 500,
+      render :template => "wash_out/#{soap_config.wsdl_style}/error", :status => 500,
              :layout => false,
              :locals => { :error_message => message, :error_code => (code || 'Server') },
              :content_type => 'text/xml'
     end
 
     def self.included(controller)
-      controller.send :around_filter, :_catch_soap_errors
+      entity = if defined?(Rails::VERSION::MAJOR) && (Rails::VERSION::MAJOR >= 4)
+        'action'
+      else
+        'filter' 
+      end
+
+      controller.send :"around_#{entity}", :_catch_soap_errors
       controller.send :helper, :wash_out
-      controller.send :before_filter, :_authenticate_wsse,     :except => [
-        :_generate_wsdl, :_invalid_action ]
-      controller.send :before_filter, :_map_soap_parameters,   :except => [
-        :_generate_wsdl, :_invalid_action ]
-      controller.send :skip_before_filter, :verify_authenticity_token
+      controller.send :"before_#{entity}", :_authenticate_wsse,   :if => :soap_action?
+      controller.send :"before_#{entity}", :_map_soap_parameters, :if => :soap_action?
+      controller.send :"skip_before_#{entity}", :verify_authenticity_token
     end
 
-    def self.deep_select(hash, result=[], &blk)
-      result += Hash[hash.select(&blk)].values
+    def self.deep_select(collection, result=[], &blk)
+      values = collection.respond_to?(:values) ? collection.values : collection
+      result += values.select(&blk)
 
-      hash.each do |key, value|
-        result = deep_select(value, result, &blk) if value.is_a? Hash
+      values.each do |value|
+        if value.is_a?(Hash) || value.is_a?(Array)
+          result = deep_select(value, result, &blk)
+        end
       end
 
       result
     end
 
-    def self.deep_replace_href(hash, replace)
-      return replace[hash[:@href]] if hash.has_key?(:@href)
+    def self.deep_replace_href(element, replace)
+      return element unless element.is_a?(Array) || element.is_a?(Hash)
 
-      hash.keys.each do |key, value|
-        hash[key] = deep_replace_href(hash[key], replace) if hash[key].is_a?(Hash)
+      if element.is_a?(Array) # Traverse arrays
+        return element.map{|x| deep_replace_href(x, replace)}
       end
 
-      hash
+      if element.has_key?(:@href) # Replace needle and traverse replacement
+        return deep_replace_href(replace[element[:@href]], replace)
+      end
+
+      element.each do |key, value| # Traverse hashes
+        element[key] = deep_replace_href(value, replace)
+      end
+
+      element
     end
 
     private
+    def soap_action?
+      soap_action.present?
+    end
 
     def action_spec
       self.class.soap_actions[soap_action]
     end
 
+    def request_input_tag
+      action_spec[:request_tag]
+    end
+
     def soap_action
       request.env['wash_out.soap_action']
     end
 
     def xml_data
-      xml_data = env['wash_out.soap_data'].values_at(:envelope, :Envelope).compact.first
-      xml_data = xml_data.values_at(:body, :Body).compact.first
-      xml_data = xml_data.values_at(soap_action.underscore.to_sym, soap_action.to_sym).compact.first || {}
+      xml_data = request.env['wash_out.soap_data'].values_at(:envelope, :Envelope).compact.first
+      xml_data = xml_data.values_at(:body, :Body).compact.first || {}
+      return xml_data if soap_config.wsdl_style == "document"
+      xml_data = xml_data.values_at(soap_action.underscore.to_sym, soap_action.to_sym, request_input_tag.to_sym).compact.first || {}
     end
 
   end

data/lib/wash_out/param.rb

@@ -7,6 +7,7 @@ module WashOut
     attr_accessor :multiplied
     attr_accessor :value
     attr_accessor :source_class
+    attr_accessor :soap_config
 
     # Defines a WSDL parameter with name +name+ and type specifier +type+.
     # The type specifier format is described in #parse_def.
@@ -63,6 +64,7 @@ module WashOut
         operation = case type
           when 'string';       :to_s
           when 'integer';      :to_i
+          when 'long';         :to_i
           when 'double';       :to_f
           when 'boolean';      lambda{|dat| dat === "0" ? false : !!dat}
           when 'date';         :to_date
@@ -160,10 +162,19 @@ module WashOut
     def flat_copy
       copy = self.class.new(@soap_config, @name, @type.to_sym, @multiplied)
       copy.raw_name = raw_name
-      copy.source_class = copy.source_class
+      copy.source_class = source_class
       copy
     end
 
+    def attribute?
+      name[0] == "@"
+    end
+
+    def attr_name
+      raise 'Not attribute' unless attribute?
+      name[1..-1]
+    end
+
     private
 
     # Used to load an entire structure.
@@ -178,7 +189,8 @@ module WashOut
       # RUBY18 Enumerable#each_with_object is better, but 1.9 only.
       @map.map do |param|
         if data.has_key? param.raw_name
-          struct[param.raw_name] = yield param, data, param.raw_name
+          param_name = param.attribute? ? param.attr_name : param.raw_name
+          struct[param_name] = yield param, data, param.raw_name
         end
       end
 

data/lib/wash_out/router.rb

@@ -4,6 +4,26 @@ module WashOut
   # This class is a Rack middleware used to route SOAP requests to a proper
   # action of a given SOAP controller.
   class Router
+    def self.url(request, controller_name)
+      route = Rails.application.routes.routes.select do |x|
+        defaults = x.defaults
+        defaults = defaults[:defaults] if defaults.include?(:defaults) # Rails 5
+        defaults[:controller] == controller_name && defaults[:action] == 'soap'
+      end.first
+
+      path = if route.respond_to?(:optimized_path)      # Rails 4
+        route.optimized_path
+      elsif route.path.respond_to?(:build_formatter)    # Rails 5
+        route.path.build_formatter.evaluate(nil)
+      else
+        route.format({})                                # Rails 3.2
+      end
+
+      path = path.join('') if path.is_a?(Array)
+
+      request.protocol + request.host_with_port + path
+    end
+
     def initialize(controller_name)
       @controller_name = "#{controller_name.to_s}_controller".camelize
     end
@@ -17,15 +37,13 @@ module WashOut
 
       soap_action = controller.soap_config.soap_action_routing ? env['HTTP_SOAPACTION'].to_s.gsub(/^"(.*)"$/, '\1')
                                                                : ''
-
       if soap_action.blank?
         parsed_soap_body = nori(controller.soap_config.snakecase_input).parse(soap_body env)
         return nil if parsed_soap_body.blank?
 
-        soap_action = parsed_soap_body
-            .values_at(:envelope, :Envelope).compact.first
-            .values_at(:body, :Body).compact.first
-            .keys.first.to_s
+        soap_action = parsed_soap_body.values_at(:envelope, :Envelope).try(:compact).try(:first)
+        soap_action = soap_action.values_at(:body, :Body).try(:compact).try(:first) if soap_action
+        soap_action = soap_action.keys.first.to_s if soap_action
       end
 
       # RUBY18 1.8 does not have force_encoding.
@@ -52,18 +70,17 @@ module WashOut
     end
 
     def soap_body(env)
-      # Don't let nobody intercept us ^_^
-      env['rack.input'].rewind if env['rack.input'].respond_to?(:rewind)
-
-      env['rack.input'].respond_to?(:string) ? env['rack.input'].string
-                                             : env['rack.input'].read
+      body = env['rack.input']
+      body.rewind if body.respond_to? :rewind
+      body.respond_to?(:string) ? body.string : body.read
+    ensure
+      body.rewind if body.respond_to? :rewind
     end
 
     def parse_soap_parameters(env)
       return env['wash_out.soap_data'] if env['wash_out.soap_data']
-
       env['wash_out.soap_data'] = nori(controller.soap_config.snakecase_input).parse(soap_body env)
-      references = WashOut::Dispatcher.deep_select(env['wash_out.soap_data']){|k,v| v.is_a?(Hash) && v.has_key?(:@id)}
+      references = WashOut::Dispatcher.deep_select(env['wash_out.soap_data']){|v| v.is_a?(Hash) && v.has_key?(:@id)}
 
       unless references.blank?
         replaces = {}; references.each{|r| replaces['#'+r[:@id]] = r}
@@ -76,17 +93,19 @@ module WashOut
     def call(env)
       @controller = @controller_name.constantize
 
-      soap_action     = parse_soap_action(env)
-      return [200, {}, ['OK']] if soap_action.blank?
-
-      soap_parameters = parse_soap_parameters(env)
-
-      action_spec = controller.soap_actions[soap_action]
+      soap_action = parse_soap_action(env)
 
-      if action_spec
-        action = action_spec[:to]
+      action = if soap_action.blank?
+        '_invalid_request'
       else
-        action = '_invalid_action'
+        soap_parameters = parse_soap_parameters(env)
+        action_spec     = controller.soap_actions[soap_action]
+
+        if action_spec
+          action_spec[:to]
+        else
+          '_invalid_action'
+        end
       end
 
       controller.action(action).call(env)

data/lib/wash_out/soap.rb

@@ -30,6 +30,7 @@ module WashOut
 
         self.soap_actions[action] = options.merge(
           :in           => WashOut::Param.parse_def(soap_config, options[:args]),
+          :request_tag  => options[:as] || action,
           :out          => WashOut::Param.parse_def(soap_config, options[:return]),
           :to           => options[:to] || action,
           :response_tag => options[:response_tag] || default_response_tag

data/lib/wash_out/version.rb

@@ -1,3 +1,3 @@
 module WashOut
-  VERSION = "0.9.2"
+  VERSION = "0.11.0.beta.1"
 end

data/lib/wash_out/wsse.rb

@@ -49,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
@@ -62,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|

data/lib/wash_out.rb

@@ -11,15 +11,28 @@ require 'wash_out/model'
 require 'wash_out/wsse'
 require 'wash_out/middleware'
 
+module WashOut
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+end
+
 module ActionDispatch::Routing
   class Mapper
     # Adds the routes for a SOAP endpoint at +controller+.
     def wash_out(controller_name, options={})
-      options.each_with_index { |key, value|  @scope[key] = value } if @scope
-      controller_class_name = [options[:module], controller_name].compact.join("/")
+      if @scope
+        scope_frame = @scope.respond_to?(:frame) ? @scope.frame : @scope
+        options.each{ |key, value|  scope_frame[key] = value }
+      end
+
+      controller_class_name = [scope_frame[:module], controller_name].compact.join("/").underscore
 
-      match "#{controller_name}/wsdl"   => "#{controller_name}#_generate_wsdl", :via => :get, :format => false
-      match "#{controller_name}/action" => WashOut::Router.new(controller_class_name), :via => [:get, :post], :defaults => { :controller => controller_class_name, :action => '_action' }, :format => false
+      match "#{controller_name}/wsdl"   => "#{controller_name}#_generate_wsdl", :via => :get, :format => false,
+        :as => "#{controller_class_name}_wsdl"
+      match "#{controller_name}/action" => WashOut::Router.new(controller_class_name), :via => [:get, :post],
+        :defaults => { :controller => controller_class_name, :action => 'soap' }, :format => false,
+        :as => "#{controller_class_name}_soap"
     end
   end
 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/fixtures/nested_refs_to_arrays.xml

@@ -0,0 +1,19 @@
+<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
+  <s:Body s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+    <parent href="#id1" />
+    <q2:child id="id1" xsi:type="q2:child" xmlns:q2="urn:FakeService">
+      <first_list href="#id2" />
+      <second_list href="#id3" />
+    </q2:child>
+    <q3:Array id="id2" q3:arrayType="xsd:int[1]" xmlns:q3="http://schemas.xmlsoap.org/soap/encoding/">
+      <Item>1</Item>
+      <Item>2</Item>
+    </q3:Array>
+    <q4:Array id="id3" q4:arrayType="xsd:int[1]" xmlns:q4="http://schemas.xmlsoap.org/soap/encoding/">
+      <Item>11</Item>
+      <Item>22</Item>
+    </q4:Array>
+  </s:Body>
+</s:Envelope>

data/spec/fixtures/ref_to_one_array.xml

@@ -0,0 +1,11 @@
+<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
+  <s:Body s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+    <list href="#id1" />
+    <q1:Array id="id1" q1:arrayType="xsd:int[1]" xmlns:q1="http://schemas.xmlsoap.org/soap/encoding/">
+      <Item>1</Item>
+      <Item>2</Item>
+    </q1:Array>
+  </s:Body>
+</s:Envelope>

data/spec/fixtures/refs_to_arrays.xml

@@ -0,0 +1,16 @@
+<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
+  <s:Body s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+    <first_list href="#id1" />
+    <second_list href="#id2" />
+    <q1:Array id="id1" q1:arrayType="xsd:int[1]" xmlns:q1="http://schemas.xmlsoap.org/soap/encoding/">
+      <Item>1</Item>
+      <Item>2</Item>
+    </q1:Array>
+    <q2:Array id="id2" q2:arrayType="xsd:int[1]" xmlns:q2="http://schemas.xmlsoap.org/soap/encoding/">
+      <Item>11</Item>
+      <Item>22</Item>
+    </q2:Array>
+  </s:Body>
+</s:Envelope>

data/spec/lib/wash_out/dispatcher_spec.rb

@@ -12,20 +12,127 @@ describe WashOut::Dispatcher do
     end
   end
 
-  it "finds nested hashes" do
-    WashOut::Dispatcher.deep_select(:foo => 1){|k,v| k == :foo}.should == [1]
-    WashOut::Dispatcher.deep_select({:foo => {:foo => 1}}){|k,v| k == :foo}.should == [{:foo => 1}, 1]
+  describe ".deep_select" do
+    blk = lambda{|v| v.is_a?(Hash) && v.has_key?(:@id)}
+
+    it "find no elements if there aren't any ids" do
+      expect(WashOut::Dispatcher.deep_select({k: {v: :v2}}, &blk)).to eq []
+    end
+
+    it "finds elements with ids in a hash" do
+      expect(WashOut::Dispatcher.deep_select({k: {:@id => 5, x: :y}}, &blk)).to eq [{:@id => 5, x: :y}]
+    end
+
+    it "finds elements with ids in a array" do
+      expect(WashOut::Dispatcher.deep_select({k: [{:@id => 5, x: :y}]}, &blk)).to eq [{:@id => 5, x: :y}]
+    end
+
+    it "finds elements with ids in hashes" do
+      expect(WashOut::Dispatcher.deep_select(
+        {
+          k: {:@id => 5, x: :y},
+          k2: {:@id => 6, n: :m}
+        }, &blk)).to eq [{:@id => 5, x: :y}, {:@id => 6, n: :m}]
+    end
+
+    it "finds elements in a hash and in a array" do
+      expect(WashOut::Dispatcher.deep_select(
+        {
+          k: [{:@id => 5, x: :y}],
+          k2: {:@id => 6, n: :m}
+        }, &blk)).to contain_exactly({:@id => 5, x: :y}, {:@id => 6, n: :m})
+    end
+
+    it "finds elements with ids in multiple arrays" do
+      expect(WashOut::Dispatcher.deep_select(
+        {
+          k: [{:@id => 5, x: :y}],
+          k2: [{:@id => 6, n: :m}]
+        }, &blk)).to eq [{:@id => 5, x: :y}, {:@id => 6, n: :m}]
+    end
   end
 
-  it "replaces nested hashed" do
-    WashOut::Dispatcher.deep_replace_href({:foo => {:@href => 1}}, {1 => 2}).should == {:foo => 2}
-    WashOut::Dispatcher.deep_replace_href({:bar => {:foo => {:@href => 1}}}, {1 => 2}).should == {:bar => {:foo => 2}}
+  describe ".deep_replace_href" do
+    it "replaces nested hashed" do
+      expect(WashOut::Dispatcher.deep_replace_href(
+        {:foo => {:@href => 1}},
+        {1 => 2})).to eq(
+          {:foo => 2}
+        )
+    end
+
+    it "replaces deeper nested hashes" do
+      expect(WashOut::Dispatcher.deep_replace_href(
+        {:bar => {:foo => {:@href => 1}}},
+        {1 => 2}
+      )).to eq(
+        {:bar => {:foo => 2}}
+      )
+    end
+
+    it "replace nested refs" do
+      hash = {fizz: {:@href => "#id4"}}
+      replaces = {
+        "#id4" => {:@href => "#id6"},
+        "#id6" => {foo: :bar}
+      }
+      expect(WashOut::Dispatcher.deep_replace_href(hash, replaces)).to eq({
+        fizz: {foo: :bar}})
+    end
+
+    it "replace really nested refs" do
+      hash = {fizz: {:@href => "#id4"}}
+      replaces = {
+        "#id4" => {:@href => "#id6"},
+        "#id6" => {:@href => "#id7"},
+        "#id7" => {foo: :bar}
+      }
+      expect(WashOut::Dispatcher.deep_replace_href(hash, replaces)).to eq({
+        fizz: {foo: :bar}})
+    end
+
+    it "replaces arrays in nested hashes" do
+      hash = {
+        fizz: {:@href => "#id4"},
+        Array: [
+          {Item: [{:@href => "#id6"}, {:@href => "#id7"}]},
+          {Item: {loo: :iioo}}
+        ]
+      }
+      replaces = {
+        "#id4" => {Item: [{:@href => "#id6"}, {:@href => "#id7"}]},
+        "#id6" => {foo: :bar},
+        "#id7" => {baz: :bats}
+      }
+      expect(WashOut::Dispatcher.deep_replace_href(hash, replaces)).to eq({
+        fizz: {Item: [
+          {foo: :bar},
+          {baz: :bats}
+        ]},
+        Array: [
+          {Item: [{foo: :bar}, {baz: :bats}]},
+          {Item: {loo: :iioo}}
+        ]
+      })
+    end
+
+    it "can traverse arrays that do not contain hashes" do
+      hash = {
+        fizz: {:@href => "#id1"},
+      }
+      replaces = {
+        "#id1" => {Item: ["1", "2"]},
+      }
+      expect(WashOut::Dispatcher.deep_replace_href(hash, replaces)).to eq({
+        fizz: {Item: ["1", "2"]},
+      })
+    end
   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,11 +152,11 @@ describe WashOut::Dispatcher 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
@@ -57,13 +164,13 @@ describe WashOut::Dispatcher do
     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, {:empty => :string } ))
-      allow(dispatcher).to receive(:xml_data).and_return(:empty => { :"@xsi:type" => "xsd:string" })
+      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" do
+    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('empty' => nil)
+      expect(dispatcher.params).to eq("foo" => { "bar" => "buzz", "empty" => nil })
     end
   end
 
@@ -73,25 +180,25 @@ describe WashOut::Dispatcher do
     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