savon 0.5.3 → 0.6.0

data/lib/savon/wsdl.rb

@@ -2,10 +2,8 @@ module Savon
 
   # Savon::WSDL
   #
-  # Savon::WSDL represents a WSDL document. A WSDL document serves as a more
-  # or less qualitative API documentation.
+  # Represents a WSDL document.
   class WSDL
-    include Validation
 
     # Expects a Savon::Request object.
     def initialize(request)
@@ -17,21 +15,23 @@ module Savon
       @namespace_uri ||= parse_namespace_uri
     end
 
-    # Returns an Array of available SOAP actions from the WSDL.
+    # Returns a Hash of available SOAP actions mapped to snake_case (keys)
+    # and their original names and inputs in another Hash (values).
     def soap_actions
-      mapped_soap_actions.keys
+      @soap_actions ||= parse_soap_operations.inject({}) do |hash, (input, action)|
+        hash.merge input.snakecase.to_sym => { :name => action, :input => input }
+      end
     end
 
-    # Returns a Hash of available SOAP actions and their original names.
-    def mapped_soap_actions
-      @mapped_soap_actions ||= parse_soap_actions.inject Hash.new do |hash, soap_action|
-        hash.merge soap_action.snakecase.to_sym => soap_action
-      end
+    # Returns +true+ for available methods and SOAP actions.
+    def respond_to?(method)
+      return true if soap_actions.keys.include? method
+      super
     end
 
-    # Returns the WSDL or +nil+ in case the WSDL could not be retrieved.
+    # Returns the WSDL document.
     def to_s
-      wsdl_response ? wsdl_response.body : nil
+      wsdl_response.body
     end
 
   private
@@ -41,7 +41,7 @@ module Savon
     def wsdl_response
       unless @wsdl_response
         @wsdl_response ||= @request.wsdl
-        invalid! :wsdl, @request.endpoint unless soap_actions && !soap_actions.empty?
+        raise ArgumentError, "Invalid WSDL: #{@request.endpoint}" if soap_actions.empty?
       end
       @wsdl_response
     end
@@ -57,12 +57,19 @@ module Savon
       definitions.attributes["targetNamespace"] if definitions
     end
 
-    # Parses the WSDL for available SOAP actions.
-    def parse_soap_actions
-      document.elements.collect "//[@soapAction]" do |element|
-        element.parent.attributes["name"]
+    # Parses the WSDL for available SOAP actions and inputs. Returns a Hash
+    # containing the SOAP action inputs and corresponding SOAP actions.
+    def parse_soap_operations
+      wsdl_binding = document.elements["//wsdl:binding"]
+      return {} unless wsdl_binding
+
+      wsdl_binding.elements.inject("//wsdl:operation", {}) do |hash, operation|
+        action = operation.elements["*:operation"].attributes["soapAction"] || ""
+        action = operation.attributes["name"] if action.empty?
+
+        hash.merge action.split("/").last => action
       end
     end
 
   end
-end
+end

data/lib/savon/wsse.rb

@@ -2,8 +2,8 @@ module Savon
 
   # Savon::WSSE
   #
-  # Includes support methods for adding WSSE authentication to a SOAP request.
-  module WSSE
+  # Represents parameters for WSSE authentication.
+  class WSSE
 
     # Namespace for WS Security Secext.
     WSENamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
@@ -12,99 +12,104 @@ module Savon
     WSUNamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
 
     # Default WSSE username.
-    @username = nil
+    @username = ""
 
     # Default WSSE password.
-    @password = nil
+    @password = ""
 
     # Default for whether to use WSSE digest.
     @digest = false
 
     class << self
 
-      # Accessor for the default WSSE username.
-      attr_accessor :username
+      # Returns the default WSSE username.
+      attr_reader :username
 
-      # Accessor for the default WSSE password.
-      attr_accessor :password
+      # Sets the default WSSE username.
+      def username=(username)
+        @username = username.to_s if username.respond_to? :to_s
+      end
+
+      # Returns the default WSSE password.
+      attr_reader :password
+
+      # Sets the default WSSE password.
+      def password=(password)
+        @password = password.to_s if password.respond_to? :to_s
+      end
 
       # Sets whether to use WSSE digest by default.
       attr_writer :digest
 
-      # Returns whether to use WSSE digest by default. 
+      # Returns whether to use WSSE digest by default.
       def digest?
         @digest
       end
 
     end
 
-    # Returns whether WSSE authentication was set via options.
-    def wsse?
-      options[:wsse] = {} unless options[:wsse].kind_of? Hash
-      wsse_username && wsse_password
+    # Sets the WSSE username.
+    def username=(username)
+      @username = username.to_s if username.respond_to? :to_s
     end
 
-    # Takes a Builder::XmlMarkup instance and appends a WSSE header.
-    def wsse_header(xml)
-      options[:wsse] = {} unless options[:wsse].kind_of? Hash
-
-      xml.wsse :Security, "xmlns:wsse" => WSENamespace do
-        xml.wsse :UsernameToken, "xmlns:wsu" => WSUNamespace do
-          wsse_nodes xml
-        end
-      end
+    # Returns the WSSE username. Defaults to the global default.
+    def username
+      @username || self.class.username
     end
 
-  private
-
-    # Returns the WSSE username or false in case no username was found.
-    def wsse_username
-      username = options[:wsse][:username] || WSSE.username
-      username ? username : false
+    # Sets the WSSE password.
+    def password=(password)
+      @password = password.to_s if password.respond_to? :to_s
     end
 
-    # Returns the WSSE password or false in case no password was found.
-    def wsse_password
-      password = options[:wsse][:password] || WSSE.password
-      password ? password : false
+    # Returns the WSSE password. Defaults to the global default.
+    def password
+      @password || self.class.password
     end
 
-    # Returns whether to use WSSE digest authentication based on options.
+    # Sets whether to use WSSE digest.
+    attr_writer :digest
+
+    # Returns whether to use WSSE digest. Defaults to the global default. 
     def digest?
-      digest = options[:wsse][:digest] || WSSE.digest?
-      digest ? true : false
+      @digest || self.class.digest?
     end
 
-    # Takes a Builder::XmlMarkup instance and appends the credentials for
-    # WSSE authentication.
-    def wsse_nodes(xml)
-      xml.wsse :Username, wsse_username
-      xml.wsse :Nonce, wsse_nonce
-      xml.wsu :Created, wsse_timestamp
-      xml.wsse :Password, wsse_password_node
+    # Returns the XML for a WSSE header or an empty String unless username
+    # and password are specified.
+    def header
+      return "" unless username && password
+
+      builder = Builder::XmlMarkup.new
+      builder.wsse :Security, "xmlns:wsse" => WSENamespace do |xml|
+        xml.wsse :UsernameToken, "xmlns:wsu" => WSUNamespace do
+          xml.wsse :Username, username
+          xml.wsse :Nonce, nonce
+          xml.wsu :Created, timestamp
+          xml.wsse :Password, password_node
+        end
+      end
     end
 
+  private
+
     # Returns the WSSE password. Encrypts the password for digest authentication.
-    def wsse_password_node
-      return wsse_password unless digest?
+    def password_node
+      return password unless digest?
 
-      token = wsse_nonce + wsse_timestamp + wsse_password
+      token = nonce + timestamp + password
       Base64.encode64(Digest::SHA1.hexdigest(token)).chomp!
     end
 
     # Returns a WSSE nonce.
-    def wsse_nonce
-      @wsse_nonce ||= Digest::SHA1.hexdigest random_string + wsse_timestamp
+    def nonce
+      @nonce ||= Digest::SHA1.hexdigest String.random + timestamp
     end
 
     # Returns a WSSE timestamp.
-    def wsse_timestamp
-      @wsse_timestamp ||= Time.now.strftime Savon::SOAPDateTimeFormat
-    end
-
-    # Returns a random String of a given +length+.
-    def random_string(length = 100)
-      (0...length).map { ("a".."z").to_a[rand(26)] }.join
+    def timestamp
+      @timestamp ||= Time.now.strftime Savon::SOAPDateTimeFormat
     end
 
   end

data/spec/fixtures/user_fixture.rb

@@ -1,14 +1,26 @@
 class UserFixture
 
   @namespace_uri = "http://v1_0.ws.user.example.com"
-  @soap_actions = { :user_find_by_id => "User.FindById", :find_user => "findUser" }
+  @soap_actions = {
+    :user_find_by_id => { :name => "User.FindById", :input => "User.FindById" },
+    :find_user => { :name => "findUser", :input => "findUser" }
+  }
 
   @datetime_string = "2010-11-22T11:22:33"
   @datetime_object = DateTime.parse @datetime_string
 
-  @response_hash = { :id => "666", :active => true, :username => "thedude",
-    :firstname => "The", :lastname => "Dude", :email => "thedude@example.com",
-    :registered => @datetime_object }
+  @response_hash = {
+    :ns2 => "http://v1_0.ws.user.example.com",
+    :return => {
+      :active => true,
+      :firstname => "The",
+      :lastname => "Dude",
+      :email => "thedude@example.com",
+      :id => "666",
+      :registered => @datetime_object,
+      :username => "thedude"
+    }
+  }
 
   class << self
 

data/spec/savon/client_spec.rb

@@ -1,72 +1,15 @@
 require "spec_helper"
 
 describe Savon::Client do
-  before { @client = new_client_instance }
+  before { @client = some_client_instance }
 
-  def new_client_instance
+  def some_client_instance
     Savon::Client.new SpecHelper.some_endpoint
   end
 
-  describe "@response_process" do
-    it "expects a Net::HTTPResponse, translates the response" <<
-       "into a Hash and returns the SOAP response body" do
-      response = Savon::Client.response_process.call(http_response_mock)
-
-      response.should be_a Hash
-      UserFixture.response_hash.each do |key, value|
-        response[key].should == value
-      end
-    end
-
-    it "has accessor methods" do
-      response_process = Savon::Client.response_process
-
-      Savon::Client.response_process = "process"
-      Savon::Client.response_process.should == "process"
-      Savon::Client.response_process = response_process
-      Savon::Client.response_process.should == response_process
-    end
-  end
-
-  describe "@error_handling" do
-    before { @error_handling = Savon::Client.error_handling }
-
-    it "raises a Savon::SOAPFault in case it finds a SOAP fault" do
-      body = { "soapenv:Fault" => {
-        "faultcode" => "soap:Server",
-        "faultstring" => "Fault occurred while processing."
-      } }
-
-      lambda { @error_handling.call(http_response_mock, body) }.
-        should raise_error Savon::SOAPFault
-    end
-
-    it "raises a Savon::SOAPFault in case it finds both HTTPError and SOAP fault" do
-      body = { "soapenv:Fault" => {
-        "faultcode" => "soap:Server",
-        "faultstring" => "Fault occurred while processing."
-      } }
-
-      lambda { @error_handling.call(http_response_mock(500), body) }.
-        should raise_error Savon::SOAPFault
-    end
-
-    it "raises a Savon::HTTPError in case it finds an HTTP error" do
-      body = { "someResponse" => "whatever" }
-
-      lambda { @error_handling.call(http_response_mock(404), body) }.
-        should raise_error Savon::HTTPError
-    end
-
-    it "passes without raising anything otherwise" do
-      body = { "someResponse" => "whatever" }
-      @error_handling.call(http_response_mock, body).should be_nil
-    end
-  end
-
   describe "initialize" do
     it "expects a SOAP endpoint String" do
-      new_client_instance
+      some_client_instance
     end
 
     it "raises an ArgumentError in case of an invalid endpoint" do
@@ -76,19 +19,7 @@ describe Savon::Client do
 
   describe "wsdl" do
     it "returns the Savon::WSDL" do
-      @client.find_user
-
       @client.wsdl.should be_a Savon::WSDL
-      @client.wsdl.to_s.should == UserFixture.user_wsdl
-    end
-  end
-  
-  describe "response" do
-    it "returns the Net::HTTPResponse of the last SOAP request" do
-      @client.find_user
-
-      @client.response.should be_a Net::HTTPResponse
-      @client.response.body.should == UserFixture.user_response
     end
   end
 
@@ -100,61 +31,13 @@ describe Savon::Client do
 
     it "still behaves like usual otherwise" do
       @client.respond_to?(:object_id).should be_true
-      @client.respond_to?(:some_missing_method).should be_false
+      @client.respond_to?(:some_undefined_method).should be_false
     end
   end
 
   describe "method_missing" do
     it "dispatches SOAP requests for available SOAP actions" do
-      @client.find_user.should be_a Hash
-    end
-
-    it "still returns a NoMethodError for missing methods" do
-      lambda { @client.some_missing_method }.should raise_error NoMethodError
-    end
-
-    it "accepts a Hash for specifying the SOAP body" do
-      soap_body_hash = { :id => 666 }
-      @client.find_user soap_body_hash
-
-      @client.instance_variable_get("@soap").body.
-        should include soap_body_hash.to_soap_xml
-    end
-
-    it "accepts a String for specifying the SOAP body" do
-      soap_body_xml = "<username>dude</username>"
-      @client.find_user soap_body_xml
-
-      @client.instance_variable_get("@soap").body.
-        should include soap_body_xml
-    end
-
-    describe "accepts a Hash of per request options" do
-      it "to specify the SOAP version" do
-        @client.find_user nil, :soap_version => 2
-        @client.instance_variable_get("@soap").version.should == 2
-      end
-
-      it "to specify credentials for WSSE authentication" do
-        @client.find_user nil, :wsse =>
-          { :username => "gorilla", :password => "secret" }
-
-        @client.instance_variable_get("@soap").body.should include "gorilla"
-        @client.instance_variable_get("@soap").body.should include "secret"
-      end
-
-      it "to specify credentials for WSSE digestauthentication" do
-        @client.find_user nil, :wsse =>
-          { :username => "gorilla", :password => "secret", :digest => true }
-
-        @client.instance_variable_get("@soap").body.should include "gorilla"
-        @client.instance_variable_get("@soap").body.should_not include "secret"
-      end
-    end
-
-    it "accepts a block for specifying the response process per request" do
-      @client.find_user { |response| response.body }.
-        should == UserFixture.user_response
+      @client.find_user.should be_a Savon::Response
     end
 
     it "raises a Savon::SOAPFault in case of a SOAP fault" do
@@ -166,13 +49,21 @@ describe Savon::Client do
       client = Savon::Client.new SpecHelper.httperror_endpoint
       lambda { client.find_user }.should raise_error Savon::HTTPError
     end
-  end
 
-  def http_response_mock(code = 200)
-    http_response_mock = mock "Net::HTTPResponse"
-    http_response_mock.stubs :code => code.to_s, :message => "OK",
-        :content_type => "text/html", :body => UserFixture.user_response
-    http_response_mock
+    it "yields the SOAP object to a block that expects one argument" do
+      @client.find_user { |soap| soap.should be_a Savon::SOAP }
+    end
+
+    it "yields the SOAP and WSSE object to a block that expects two argument" do
+      @client.find_user do |soap, wsse|
+        soap.should be_a Savon::SOAP
+        wsse.should be_a Savon::WSSE
+      end
+    end
+
+    it "still raises a NoMethodError for undefined methods" do
+      lambda { @client.some_undefined_method }.should raise_error NoMethodError
+    end
   end
 
-end
+end