RubyGems - nogara-wash_out - Versions diffs - 0.5.2 - Mend

nogara-wash_out 0.5.2

Files changed (59) hide show

data/.gitignore +9 -0
data/.travis.yml +3 -0
data/Appraisals +7 -0
data/CHANGELOG.md +79 -0
data/Gemfile +5 -0
data/Gemfile.lock +118 -0
data/LICENSE +22 -0
data/README.md +181 -0
data/Rakefile +14 -0
data/app/helpers/wash_out_helper.rb +64 -0
data/app/views/wash_with_soap/error.builder +10 -0
data/app/views/wash_with_soap/response.builder +13 -0
data/app/views/wash_with_soap/wsdl.builder +68 -0
data/gemfiles/rails-3.0.11.gemfile +8 -0
data/gemfiles/rails-3.0.11.gemfile.lock +130 -0
data/gemfiles/rails-3.1.3.gemfile +8 -0
data/gemfiles/rails-3.1.3.gemfile.lock +141 -0
data/init.rb +1 -0
data/lib/wash_out.rb +35 -0
data/lib/wash_out/dispatcher.rb +206 -0
data/lib/wash_out/engine.rb +30 -0
data/lib/wash_out/model.rb +25 -0
data/lib/wash_out/param.rb +176 -0
data/lib/wash_out/router.rb +36 -0
data/lib/wash_out/soap.rb +40 -0
data/lib/wash_out/type.rb +28 -0
data/lib/wash_out/version.rb +3 -0
data/lib/wash_out/wsse.rb +79 -0
data/spec/dummy/Rakefile +7 -0
data/spec/dummy/app/controllers/application_controller.rb +3 -0
data/spec/dummy/app/helpers/application_helper.rb +2 -0
data/spec/dummy/app/views/layouts/application.html.erb +14 -0
data/spec/dummy/config.ru +4 -0
data/spec/dummy/config/application.rb +42 -0
data/spec/dummy/config/boot.rb +10 -0
data/spec/dummy/config/environment.rb +5 -0
data/spec/dummy/config/environments/development.rb +23 -0
data/spec/dummy/config/environments/test.rb +30 -0
data/spec/dummy/config/initializers/backtrace_silencers.rb +7 -0
data/spec/dummy/config/initializers/inflections.rb +10 -0
data/spec/dummy/config/initializers/mime_types.rb +5 -0
data/spec/dummy/config/initializers/secret_token.rb +7 -0
data/spec/dummy/config/initializers/session_store.rb +8 -0
data/spec/dummy/config/locales/en.yml +5 -0
data/spec/dummy/config/routes.rb +58 -0
data/spec/dummy/public/404.html +26 -0
data/spec/dummy/public/422.html +26 -0
data/spec/dummy/public/500.html +26 -0
data/spec/dummy/public/favicon.ico +0 -0
data/spec/dummy/public/stylesheets/.gitkeep +0 -0
data/spec/dummy/script/rails +6 -0
data/spec/spec_helper.rb +51 -0
data/spec/support/httpi-rack.rb +46 -0
data/spec/wash_out/dispatcher_spec.rb +65 -0
data/spec/wash_out/param_spec.rb +26 -0
data/spec/wash_out/type_spec.rb +23 -0
data/spec/wash_out_spec.rb +686 -0
data/wash_out.gemspec +21 -0
metadata +183 -0

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The page you were looking for doesn't exist (404)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/404.html -->
+  <div class="dialog">
+    <h1>The page you were looking for doesn't exist.</h1>
+    <p>You may have mistyped the address or the page may have moved.</p>
+  </div>
+</body>
+</html>

data/spec/dummy/public/422.html ADDED

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The change you wanted was rejected (422)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/422.html -->
+  <div class="dialog">
+    <h1>The change you wanted was rejected.</h1>
+    <p>Maybe you tried to change something you didn't have access to.</p>
+  </div>
+</body>
+</html>

data/spec/dummy/public/500.html ADDED

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <h1>We're sorry, but something went wrong.</h1>
+    <p>We've been notified about this issue and we'll take a look at it shortly.</p>
+  </div>
+</body>
+</html>

data/spec/dummy/public/favicon.ico ADDED

File without changes

data/spec/dummy/public/stylesheets/.gitkeep ADDED

File without changes

data/spec/dummy/script/rails ADDED

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/spec_helper.rb ADDED

@@ -0,0 +1,51 @@
+# Configure Rails Envinronment
+ENV["RAILS_ENV"] = "test"
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+require "rspec/rails"
+Rails.backtrace_cleaner.remove_silencers!
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+RSpec.configure do |config|
+  # Remove this line if you don't want RSpec's should and should_not
+  # methods or matchers
+  require 'rspec/expectations'
+  config.include RSpec::Matchers
+  # == Mock Framework
+  config.mock_with :rspec
+end
+require 'savon'
+Savon.configure do |config|
+  config.log = false            # disable logging
+end
+HTTPI.logger = Logger.new(open("/dev/null", 'w'))
+HTTPI.adapter = :rack
+HTTPI::Adapters::Rack.mount 'app', Dummy::Application
+Dummy::Application.routes.draw do
+  wash_out :api
+end
+def client
+  Savon::Client.new do
+    wsdl.document = 'http://app/api/wsdl'
+  end
+end
+def mock_controller(&block)
+  Object.send :remove_const, :ApiController if defined?(ApiController)
+  Object.send :const_set, :ApiController, Class.new(ApplicationController) {
+    include WashOut::SOAP
+    class_exec &block if block
+  }
+end

data/spec/support/httpi-rack.rb ADDED

@@ -0,0 +1,46 @@
+require 'httpi'
+require 'httpi/response'
+module HTTPI
+  module Adapters
+    # This is an adapter for testing the Rack applications with HTTPI-capable
+    # clients.
+    class Rack
+      class << self
+        attr_accessor :mounted_apps
+      end
+      self.mounted_apps = {}
+      def self.mount(host, application)
+        self.mounted_apps[host] = application
+      end
+      def initialize(request=nil)
+      end
+      def method_missing(method, *args)
+        if %w{get post head put delete}.include?(method.to_s)
+          request, = args
+          app = self.class.mounted_apps[request.url.host]
+          mock_req = ::Rack::MockRequest.new(app)
+          env = {}
+          request.headers.each do |header, value|
+            env["HTTP_#{header.gsub('-', '_').upcase}"] = value
+          end
+          mock_resp = mock_req.request(method.to_s.upcase, request.url.to_s,
+                { :fatal => true, :input => request.body.to_s }.merge(env))
+          HTTPI::Response.new(mock_resp.status, mock_resp.headers, mock_resp.body)
+        else
+          super
+        end
+      end
+    end
+  end
+  Adapter::ADAPTERS[:rack] = { :class => Adapters::Rack, :require => 'rack/mock' }
+end

data/spec/wash_out/dispatcher_spec.rb ADDED

@@ -0,0 +1,65 @@
+#encoding:utf-8
+require 'spec_helper'
+describe WashOut::Dispatcher do
+  class TestBody
+    attr_accessor :read
+    def initialize(read); @read = read; end
+  end
+  class TestRequest
+    attr_accessor :body
+    def initialize(body); @body = body; end
+  end
+  class Dispatcher < ApplicationController
+    include WashOut::SOAP
+    def self.mock(text="")
+      dispatcher = self.new
+      dispatcher.request = TestRequest.new(TestBody.new(text))
+      dispatcher
+    end
+    def params
+      @_params
+    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]
+  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}}
+  end
+  it "parses typical request" do
+    dispatcher = Dispatcher.mock("<foo>1</foo>")
+    dispatcher._parse_soap_parameters
+    dispatcher.params.should == {:foo => "1"}
+  end
+  it "parses href request" do
+    dispatcher = Dispatcher.mock <<-XML
+      <request>
+        <entities href="#id1">
+        </entities>
+      </request>
+      <entity id="id1">
+        <foo><bar>1</bar></foo>
+        <sub href="#id2" />
+      </entity>
+      <ololo id="id2">
+        <foo>1</foo>
+      </ololo>
+    XML
+    dispatcher._parse_soap_parameters
+    dispatcher.params[:request][:entities].should == {:foo=>{:bar=>"1"}, :sub=>{:foo=>"1", :@id=>"id2"}, :@id=>"id1"}
+  end
+end

data/spec/wash_out/param_spec.rb ADDED

@@ -0,0 +1,26 @@
+#encoding:utf-8
+require 'spec_helper'
+describe WashOut::Param do
+  it "loads custom_types" do
+    class Abraka1 < WashOut::Type
+      map(
+        :test => :string
+      )
+    end
+    class Abraka2 < WashOut::Type
+      type_name 'test'
+      map :foo => Abraka1
+    end
+    map = WashOut::Param.parse_def 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'
+  end
+end

data/spec/wash_out/type_spec.rb ADDED

@@ -0,0 +1,23 @@
+#encoding:utf-8
+require 'spec_helper'
+describe WashOut::Type do
+  it "defines custom type" do
+    class Abraka1 < WashOut::Type
+      map :test => :string
+    end
+    class Abraka2 < WashOut::Type
+      type_name 'test'
+      map :foo => Abraka1
+    end
+    Abraka1.wash_out_param_name.should == 'Abraka1'
+    Abraka1.wash_out_param_map.should == {:test => :string}
+    Abraka2.wash_out_param_name.should == 'Test'
+    Abraka2.wash_out_param_map.should == {:foo => Abraka1}
+  end
+end

data/spec/wash_out_spec.rb ADDED

@@ -0,0 +1,686 @@
+#encoding:utf-8
+require 'spec_helper'
+describe WashOut do
+  before(:each) do
+    WashOut::Engine.snakecase_input = true
+    WashOut::Engine.camelize_wsdl   = true
+    WashOut::Engine.namespace = false
+  end
+  it "should be valid" do
+    WashOut.should be_a(Module)
+  end
+  it "should allow to include SOAP module" do
+    lambda {
+      mock_controller do
+        # nothing
+      end
+    }.should_not raise_exception
+  end
+  it "should generate WSDL" do
+    mock_controller do
+      soap_action :result, :args => nil, :return => :int
+      def answer
+        render :soap => "42"
+      end
+      soap_action "getArea", :args   => { :circle => { :center => { :x => [:integer],
+                                                                    :y => :integer },
+                                                       :radius => :double } },
+                             :return => { :area => :double,
+                                          :distance_from_o => :double },
+                             :to     => :get_area
+      def get_area
+        circle = params[:circle]
+        render :soap => { :area            => Math::PI * circle[:radius] ** 2,
+                          :distance_from_o => Math.sqrt(circle[:center][:x] ** 2 + circle[:center][:y] ** 2) }
+      end
+      soap_action "rocky", :args   => { :circle1 => { :x => :integer } },
+                             :return => { :circle2 => { :y => :integer } }
+      def rocky; end
+    end
+    xml    = Nori.parse client.wsdl.xml
+    # Savon underscores method names so we
+    # get back just what we have at controller
+    client.wsdl.soap_actions.map{|x| x.to_s}.sort.should == [:result, :get_area, :rocky].map{|x| x.to_s}.sort
+    x = xml[:definitions][:types][:schema][:complex_type].find{|x| x[:'@name'] == 'Center'}[:sequence][:element].find{|x| x[:'@name'] == 'X'}
+    x[:'@min_occurs'].should == "0"
+    x[:'@max_occurs'].should == "unbounded"
+    xml[:definitions][:binding][:operation].map{|e| e[:'@name']}.sort.should == ['Result', 'getArea', 'rocky'].sort
+    client.wsdl.xml.include?('<xsd:complexType name="Circle1">').should == true
+  end
+  it "should allow definition of a simple action" do
+    lambda {
+      mock_controller do
+        soap_action "answer", :args => nil, :return => :integer
+      end
+    }.should_not raise_exception
+  end
+  it "should answer to request without parameters" do
+    mock_controller do
+      soap_action "answer", :args => nil, :return => :int
+      def answer
+        render :soap => "42"
+      end
+    end
+    client.request(:answer).to_hash[:answer_response][:value].should == "42"
+  end
+  it "should respond to request with insufficient parameters" do
+    mock_controller do
+      soap_action "answer", :args => {:a => :integer}, :return => :integer
+      def answer
+        render :soap => "42"
+      end
+    end
+    client.request(:answer).to_hash[:answer_response][:value].should == "42"
+  end
+  it "should answer to request with empty parameter" do
+    mock_controller do
+      soap_action "answer", :args => {:a => :string}, :return => {:a => :string}
+      def answer
+        render :soap => {:a => params[:a]}
+      end
+    end
+    client.request(:answer) do
+      soap.body = { :a => '' }
+    end.to_hash[:answer_response][:a].should == {:"@xsi:type"=>"xsd:string"}
+  end
+  it "should answer to request with one parameter" do
+    mock_controller do
+      soap_action "checkAnswer", :args => :integer, :return => :boolean, :to => 'check_answer'
+      def check_answer
+        render :soap => (params[:value] == 42)
+      end
+    end
+    client.request(:check_answer) do
+      soap.body = { :value => 42 }
+    end.to_hash[:check_answer_response][:value].should == true
+    client.request(:check_answer) do
+      soap.body = { :value => 13 }
+    end.to_hash[:check_answer_response][:value].should == false
+  end
+  it "handles incorrect requests" do
+    mock_controller do
+      soap_action "duty",
+        :args => {:bad => {:a => :string, :b => :string}, :good => {:a => :string, :b => :string}},
+        :return => nil
+      def duty
+        render :soap => nil
+      end
+    end
+    lambda {
+      client.request(:duty) do
+        soap.body = { :bad => 42, :good => nil }
+      end
+    }.should raise_exception(Savon::SOAP::Fault)
+  end
+  it "should handle snakecase option properly" do
+    WashOut::Engine.snakecase_input = false
+    WashOut::Engine.camelize_wsdl   = false
+    mock_controller do
+      soap_action "rocknroll", :args => {:ZOMG => :string}, :return => nil
+      def rocknroll
+        params["ZOMG"].should == "yam!"
+        render :soap => nil
+      end
+    end
+    client.request(:rocknroll) do
+      soap.body = { "ZOMG" => 'yam!' }
+    end
+  end
+  context "optional arrays" do
+    it "should answer for simple structure" do
+      mock_controller do
+        soap_action "rocknroll",
+                    :args => nil, :return => { :my_value => [:integer] }
+        def rocknroll
+          render :soap => {}
+        end
+      end
+      client.request(:rocknroll).to_hash[:rocknroll_response].should be_nil
+    end
+    it "should answer for complex structure" do
+      mock_controller do
+        soap_action "rocknroll",
+                    :args => nil, :return => { :my_value => [{ :value => :integer}] }
+        def rocknroll
+          render :soap => {}
+        end
+      end
+      client.request(:rocknroll).to_hash[:rocknroll_response].should be_nil
+    end
+    it "should answer for nested complex structure" do
+      mock_controller do
+        soap_action "rocknroll",
+                    :args => nil, :return => { :my_value => { :my_array => [{ :value => :integer}] } }
+        def rocknroll
+          render :soap => {}
+        end
+      end
+      client.request(:rocknroll).to_hash[:rocknroll_response][:my_value].should == { :"@xsi:type" => "tns:MyValue" }
+    end
+  end
+  it "should answer to request with two parameter" do
+    mock_controller do
+      soap_action "funky", :args => { :a => :integer, :b => :string }, :return => :string
+      def funky
+        render :soap => ((params[:a] * 10).to_s + params[:b])
+      end
+    end
+    client.request(:funky) do
+      soap.body = { :a => 42, :b => 'k' }
+    end.to_hash[:funky_response][:value].should == '420k'
+  end
+  it "should understand nested parameter specifications" do
+    mock_controller do
+      soap_action "getArea", :args   => { :circle => { :center => { :x => :integer,
+                                                                    :y => :integer },
+                                                       :radius => :double } },
+                             :return => { :area => :double,
+                                          :distance_from_o => :double },
+                             :to     => :get_area
+      def get_area
+        circle = params[:circle]
+        render :soap => { :area            => Math::PI * circle[:radius] ** 2,
+                          :distance_from_o => Math.sqrt(circle[:center][:x] ** 2 + circle[:center][:y] ** 2) }
+      end
+    end
+    client.request(:get_area) do
+      soap.body = { :circle => { :center => { :x => 3, :y => 4 },
+                                 :radius => 5 } }
+    end.to_hash[:get_area_response].should == ({ :area => (Math::PI * 25).to_s, :distance_from_o => (5.0).to_s })
+  end
+  it "should allow arbitrary action names" do
+    name = 'AnswerToTheUltimateQuestionOfLifeTheUniverseAndEverything'
+    mock_controller do
+      soap_action name,
+                  :args => nil, :return => :integer, :to => :answer
+      def answer
+        render :soap => "forty two"
+      end
+    end
+    client.request(name).to_hash["#{name.underscore}_response".to_sym][:value].should == "forty two"
+  end
+  it "should correctly report SOAP errors" do
+    mock_controller do
+      soap_action "error", :args => { :need_error => :boolean }, :return => nil
+      def error
+        raise self.class.const_get(:SOAPError), "you wanted one" if params[:need_error]
+        render :soap => nil
+      end
+    end
+    lambda {
+      client.request(:error) do
+        soap.body = { :need_error => false }
+      end
+    }.should_not raise_exception
+    lambda {
+      client.request(:error) do
+        soap.body = { :need_error => true }
+      end
+    }.should raise_exception(Savon::SOAP::Fault)
+  end
+  it "should report a SOAP error if method does not exists" do
+    mock_controller
+    lambda {
+      client.request(:nonexistent)
+    }.should raise_exception(Savon::SOAP::Fault)
+  end
+  it "should be possible to explicitly render a SOAP error" do
+    mock_controller do
+      soap_action "error", :args => nil, :return => nil
+      def error
+        render_soap_error "a message"
+      end
+    end
+    lambda {
+      client.request(:error)
+    }.should raise_exception(Savon::SOAP::Fault)
+  end
+  it "should handle nested returns" do
+    mock_controller do
+      soap_action "gogogo",
+                  :args   => nil,
+                  :return => {
+                    :zoo => :string,
+                    :boo => {
+                      :moo => :string,
+                      :doo => :string
+                    }
+                  }
+      def gogogo
+        render :soap => {
+          :zoo => 'zoo',
+          :boo => {
+            :moo => 'moo',
+            :doo => 'doo'
+          }
+        }
+      end
+    end
+    client.request(:gogogo)[:gogogo_response].should == {:zoo=>"zoo", :boo=>{:moo=>"moo", :doo=>"doo", :"@xsi:type"=>"tns:Boo"}}
+  end
+  it "should handle arrays" do
+    mock_controller do
+      soap_action "rumba",
+                  :args   => {
+                    :rumbas => [:integer]
+                  },
+                  :return => nil
+      def rumba
+        params.should == {"rumbas" => [1, 2, 3]}
+        render :soap => nil
+      end
+    end
+    client.request(:rumba) do
+      soap.body = {
+        :rumbas => [1, 2, 3]
+      }
+    end
+  end
+  it "should handle complex structures inside arrays" do
+    mock_controller do
+      soap_action "rumba",
+                  :args   => {
+                    :rumbas => [ {
+                      :zombies => :string,
+                      :puppies => :string
+                    } ]
+                  },
+                  :return => nil
+      def rumba
+        params.should == {
+          "rumbas" => [
+            {"zombies" => 'suck', "puppies" => 'rock'},
+            {"zombies" => 'slow', "puppies" => 'fast'}
+          ]
+        }
+        render :soap => nil
+      end
+    end
+    client.request(:rumba) do
+      soap.body = {
+        :rumbas => [
+          {:zombies => 'suck', :puppies => 'rock'},
+          {:zombies => 'slow', :puppies => 'fast'}
+        ]
+      }
+    end
+  end
+  it "should be able to return arrays" do
+    mock_controller do
+      soap_action "rumba",
+                  :args   => nil,
+                  :return => [:integer]
+      def rumba
+        render :soap => [1, 2, 3]
+      end
+    end
+    client.request(:rumba).to_hash[:rumba_response].should == {:value => ["1", "2", "3"]}
+  end
+  it "should deprecate old syntax" do
+    # save rspec context check
+    raise_runtime_exception = raise_exception(RuntimeError)
+    mock_controller do
+      lambda {
+        soap_action "rumba",
+                    :args   => :integer,
+                    :return => []
+      }.should raise_runtime_exception
+      def rumba
+        render :soap => nil
+      end
+    end
+  end
+  it "should handle return of complex structures inside arrays" do
+    mock_controller do
+      soap_action "rumba",
+        :args   => nil,
+        :return => {
+          :rumbas => [{:zombies => :string, :puppies => :string}]
+        }
+      def rumba
+        render :soap =>
+          {:rumbas => [
+              {:zombies => "suck1", :puppies => "rock1" },
+              {:zombies => "suck2", :puppies => "rock2" }
+            ]
+          }
+      end
+    end
+    client.request(:rumba)[:rumba_response].should == {
+      :rumbas => [
+        {:zombies => "suck1",:puppies => "rock1", :"@xsi:type"=>"tns:Rumbas"},
+        {:zombies => "suck2", :puppies => "rock2", :"@xsi:type"=>"tns:Rumbas" }
+      ]
+    }
+  end
+  it "should handle return of structs in structs in arrays" do
+    mock_controller do
+      soap_action "rumba",
+        :args => nil,
+        :return => [{:rumbas => {:zombies => :integer}}]
+      def rumba
+        render :soap => [{:rumbas => {:zombies => 100000}}, {:rumbas => {:zombies => 2}}]
+      end
+    end
+    client.request(:rumba)[:rumba_response].should == {
+      :value => [
+        {
+          :rumbas => {
+            :zombies => "100000",
+            :"@xsi:type" => "tns:Rumbas"
+          },
+          :"@xsi:type" => "tns:Value"
+        },
+        {
+          :rumbas => {
+            :zombies => "2",
+            :"@xsi:type" => "tns:Rumbas"
+          },
+          :"@xsi:type"=>"tns:Value"
+        }
+      ]
+    }
+  end
+  it "should handle complex structs/arrays" do
+    mock_controller do
+      soap_action "rumba",
+        :args => nil,
+        :return => {
+          :rumbas => [
+            {
+              :zombies => :string,
+              :puppies => [
+                {:kittens => :integer}
+              ]
+            }
+          ]
+        }
+      def rumba
+        render :soap => {
+          :rumbas => [
+            {
+              :zombies => "abc",
+              :puppies => [
+                {:kittens => 1},
+                {:kittens => 5},
+              ]
+            },
+            {
+              :zombies => "def",
+              :puppies => [
+                {:kittens => 4}
+              ]
+            }
+          ]
+        }
+      end
+    end
+    client.request(:rumba)[:rumba_response].should == {
+      :rumbas => [
+        {
+          :zombies => "abc",
+          :puppies => [
+            {
+              :kittens => "1",
+              :"@xsi:type" => "tns:Puppies"
+            },
+            {
+              :kittens => "5",
+              :"@xsi:type" => "tns:Puppies"
+            }
+          ],
+          :"@xsi:type"=>"tns:Rumbas"
+        },
+        {
+          :zombies => "def",
+          :puppies => {
+            :kittens => "4",
+            :"@xsi:type" => "tns:Puppies"
+          },
+          :"@xsi:type"=>"tns:Rumbas"
+        }
+      ]
+    }
+  end
+  it "handles dates" 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?
+        render :soap => nil
+      end
+    end
+    client.request(:date) do
+      soap.body = {
+        :value => '2000-12-30'
+      }
+    end
+    lambda {
+      client.request(:date) do
+        soap.body = {
+          :value => nil
+        }
+      end
+    }.should_not raise_exception
+  end
+  describe "ws-security" do
+    it "should append username_token to params, if present" do
+      WashOut::Engine.wsse_username = nil
+      WashOut::Engine.wsse_password = nil
+      mock_controller 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"
+          render :soap => nil
+        end
+      end
+      client.request(:check_token) do
+        wsse.username = "gorilla"
+        wsse.password = "secret"
+        soap.body = { :value => 42 }
+      end
+    end
+    it "should handle PasswordText auth" do
+      WashOut::Engine.wsse_username = "gorilla"
+      WashOut::Engine.wsse_password = "secret"
+      mock_controller do
+        soap_action "checkAuth", :args => :integer, :return => :boolean, :to => 'check_auth'
+        def check_auth
+          render :soap => (params[:value] == 42)
+        end
+      end
+      # correct auth
+      lambda {
+        client.request(:check_auth) do
+          wsse.username = "gorilla"
+          wsse.password = "secret"
+          soap.body = { :value => 42 }
+        end
+      }.should_not raise_exception
+      # wrong user
+      lambda {
+        client.request(:check_auth) do
+          wsse.username = "chimpanzee"
+          wsse.password = "secret"
+          soap.body = { :value => 42 }
+        end
+      }.should raise_exception(Savon::SOAP::Fault)
+      # wrong pass
+      lambda {
+        client.request(:check_auth) do
+          wsse.username = "gorilla"
+          wsse.password = "nicetry"
+          soap.body = { :value => 42 }
+        end
+      }.should raise_exception(Savon::SOAP::Fault)
+      # no auth
+      lambda {
+        client.request(:check_auth) do
+          soap.body = { :value => 42 }
+        end
+      }.should raise_exception(Savon::SOAP::Fault)
+    end
+    it "should handle PasswordDigest auth" do
+      WashOut::Engine.wsse_username = "gorilla"
+      WashOut::Engine.wsse_password = "secret"
+      mock_controller do
+        soap_action "checkAuth", :args => :integer, :return => :boolean, :to => 'check_auth'
+        def check_auth
+          render :soap => (params[:value] == 42)
+        end
+      end
+      # correct auth
+      lambda {
+        client.request(:check_auth) do
+          wsse.credentials "gorilla", "secret", :digest
+          soap.body = { :value => 42 }
+        end
+      }.should_not raise_exception
+      # wrong user
+      lambda {
+        client.request(:check_auth) do
+          wsse.credentials "chimpanzee", "secret", :digest
+          soap.body = { :value => 42 }
+        end
+      }.should raise_exception(Savon::SOAP::Fault)
+      # wrong pass
+      lambda {
+        client.request(:check_auth) do
+          wsse.credentials "gorilla", "nicetry", :digest
+          soap.body = { :value => 42 }
+        end
+      }.should raise_exception(Savon::SOAP::Fault)
+    end
+  end
+  it 'will not let you pass an Array in the place of a Hash' do
+    mock_controller do
+      soap_action 'bad', :args => :integer, :return => {
+        :basic => :string,
+        :stallions => {
+          :stallion => [
+            :name => :string,
+            :wyldness => :integer,
+          ]
+        },
+      }
+      def bad
+        render :soap => {
+          :basic => 'hi',
+          :stallions => [{:name => 'ted', :wyldness => 11}]
+        }
+      end
+    end
+    lambda {
+      client.request(:bad).to_hash(:bad_response)
+    }.should raise_exception(
+      WashOut::Dispatcher::ProgrammerError,
+      /SOAP response .*wyldness.*Array.*Hash.*stallion/
+    )
+  end
+  it 'loudly fails if you return a string in place of an Array' do
+    mock_controller do
+      soap_action 'bad2', :args => :integer, :return => {
+        :basic => :string,
+        :telephone_booths => [:string]
+      }
+      def bad2
+        render :soap => {
+          :basic => 'hihi',
+          :telephone_booths => 'oops'
+        }
+      end
+    end
+    lambda {
+      client.request(:bad2).to_hash[:bad_response]
+    }.should raise_exception(
+      WashOut::Dispatcher::ProgrammerError,
+      /SOAP response .*oops.*String.*telephone_booths.*Array/
+    )
+  end
+end