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

nogara-wash_out 0.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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

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

@@ -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