pyu-savon 0.7.9.3

data/lib/savon/version.rb

@@ -0,0 +1,5 @@
+module Savon
+
+  Version = "0.7.9.3"
+
+end

data/lib/savon/wsdl.rb

@@ -0,0 +1,137 @@
+module Savon
+
+  # = Savon::WSDL
+  #
+  # Savon::WSDL represents the WSDL of your service, including information like the namespace URI,
+  # the SOAP endpoint and available SOAP actions.
+  #
+  # == The WSDL document
+  #
+  # Retrieve the raw WSDL document:
+  #
+  #   client.wsdl.to_s
+  #
+  # == Available SOAP actions
+  #
+  # Get an array of available SOAP actions:
+  #
+  #   client.wsdl.soap_actions
+  #   # => [:get_all_users, :get_user_by_id]
+  #
+  # == Namespace URI
+  #
+  # Get the namespace URI:
+  #
+  #   client.wsdl.namespace_uri
+  #   # => "http://ws.userservice.example.com"
+  #
+  # == SOAP endpoint
+  #
+  # Get the SOAP endpoint:
+  #
+  #   client.wsdl.soap_endpoint
+  #   # => "http://example.com"
+  #
+  # == Disable Savon::WSDL
+  #
+  # Especially with large services (i.e. Ebay), getting and parsing the WSDL document can really
+  # slow down your request. The WSDL is great for exploring a service, but it's recommended to
+  # disable it for production.
+  #
+  # When disabling the WSDL, you need to pay attention to certain differences:
+  #
+  # 1. You instantiate Savon::Client with the actual SOAP endpoint instead of pointing it to the
+  #    WSDL of your service.
+  # 2. You also need to manually specify the SOAP.namespace.
+  # 3. Append an exclamation mark (!) to your SOAP call:
+  #
+  #   client = Savon::Client.new "http://example.com"
+  #
+  #   client.get_user_by_id! do |soap|
+  #     soap.namespace = "http://example.com/UserService"
+  #     soap.body = { :id => 666 }
+  #   end
+  #
+  # Without the WSDL, Savon also has to guess the name of the SOAP action and input tag. It takes
+  # the name of the method called on its client instance, converts it from snake_case to lowerCamelCase
+  # and uses the result.
+  #
+  # The example above expects a SOAP action with an original name of "getUserById". If you service
+  # uses UpperCamelCase method names, you can just use the original name:
+  #
+  #   client.GetAllUsers!
+  #
+  # For special cases, you could also specify the SOAP.action and SOAP.input inside the block:
+  #
+  #   client.get_user_by_id! do |soap|
+  #     soap.namespace = "http://example.com/UserService"
+  #     soap.action = "GetUserById"
+  #     soap.input = "GetUserByIdRequest"
+  #     soap.body = { :id => 123 }
+  #   end
+  class WSDL
+
+    # Expects a Savon::Request and accepts a custom +soap_endpoint+.
+    def initialize(request, soap_endpoint = nil)
+      @request, @enabled, @soap_endpoint = request, true, soap_endpoint
+    end
+
+    # Sets whether to use the WSDL.
+    attr_writer :enabled
+
+    # Returns whether to use the WSDL. Defaults to +true+.
+    def enabled?
+      @enabled
+    end
+
+    # Returns the namespace URI of the WSDL.
+    def namespace_uri
+      @namespace_uri ||= stream.namespace_uri
+    end
+
+    # Returns an Array of available SOAP actions.
+    def soap_actions
+      @soap_actions ||= stream.operations.keys
+    end
+
+    # Returns a Hash of SOAP operations including their corresponding
+    # SOAP actions and inputs.
+    def operations
+      @operations ||= stream.operations
+    end
+
+    # Returns the SOAP endpoint.
+    def soap_endpoint
+      @soap_endpoint ||= stream.soap_endpoint
+    end
+
+    # Returns +true+ for available methods and SOAP actions.
+    def respond_to?(method)
+      return true if !enabled? || soap_actions.include?(method)
+      super
+    end
+
+    # Returns an Array containg the SOAP action and input for a given +soap_call+.
+    def operation_from(soap_action)
+      return [soap_action.to_soap_key, soap_action.to_soap_key] unless enabled?
+      [operations[soap_action][:action], operations[soap_action][:input]]
+    end
+
+    # Returns the raw WSDL document.
+    def to_s
+      @document ||= @request.wsdl.body
+    end
+
+  private
+
+    # Returns the Savon::WSDLStream.
+    def stream
+      unless @stream
+        @stream = WSDLStream.new
+        REXML::Document.parse_stream to_s, @stream
+      end
+      @stream
+    end
+
+  end
+end

data/lib/savon/wsdl_stream.rb

@@ -0,0 +1,85 @@
+module Savon
+
+  # = Savon::WSDLStream
+  #
+  # Savon::WSDLStream serves as a stream listener for parsing the WSDL document.
+  class WSDLStream
+
+    # The main sections of a WSDL document.
+    Sections = %w(definitions types message portType binding service)
+
+    def initialize
+      @path, @operations, @namespaces = [], {}, {}
+    end
+
+    # Returns the namespace URI.
+    attr_reader :namespace_uri
+
+    # Returns the SOAP operations.
+    attr_reader :operations
+
+    # Returns the SOAP endpoint.
+    attr_reader :soap_endpoint
+
+    # Hook method called when the stream parser encounters a starting tag.
+    def tag_start(tag, attrs)
+      # read xml namespaces if root element
+      read_namespaces(attrs) if @path.empty?
+
+      tag, namespace = tag.split(":").reverse
+      @path << tag
+
+      if @section == :binding && tag == "binding"
+        # ensure that we are in an wsdl/soap namespace
+        @section = nil unless @namespaces[namespace].starts_with? "http://schemas.xmlsoap.org/wsdl/soap"
+      end
+
+      @section = tag.to_sym if Sections.include?(tag) && depth <= 2
+
+      @namespace_uri ||= attrs["targetNamespace"] if @section == :definitions
+      @soap_endpoint ||= URI(URI.escape(attrs["location"])) if @section == :service && tag == "address"
+
+      operation_from tag, attrs if @section == :binding && tag == "operation"
+    end
+
+    # Returns our current depth in the WSDL document.
+    def depth
+      @path.size
+    end
+
+    # Reads namespace definitions from a given +attrs+ Hash.
+    def read_namespaces(attrs)
+      attrs.each do |key, value|
+        @namespaces[key.strip_namespace] = value if key.starts_with? "xmlns:"
+      end
+    end
+
+    # Hook method called when the stream parser encounters a closing tag.
+    def tag_end(tag)
+      @path.pop
+
+      if @section == :binding && @input && tag.strip_namespace == "operation"
+        # no soapAction attribute found till now
+        operation_from tag, "soapAction" => @input
+      end
+    end
+
+    # Stores available operations from a given tag +name+ and +attrs+.
+    def operation_from(tag, attrs)
+      @input = attrs["name"] if attrs["name"]
+
+      if attrs["soapAction"]
+        @action = !attrs["soapAction"].blank? ? attrs["soapAction"] : @input
+        @input = @action.split("/").last if !@input || @input.empty?
+
+        @operations[@input.snakecase.to_sym] = { :action => @action, :input => @input }
+        @input, @action = nil, nil
+      end
+    end
+
+    # Catches calls to unimplemented hook methods.
+    def method_missing(method, *args)
+    end
+
+  end
+end

data/lib/savon/wsse.rb

@@ -0,0 +1,163 @@
+module Savon
+
+  # = Savon::WSSE
+  #
+  # Savon::WSSE represents WSSE authentication. Pass a block to your SOAP call and the WSSE object
+  # is passed to it as the second argument. The object allows setting the WSSE username, password
+  # and whether to use digest authentication.
+  #
+  # == Credentials
+  #
+  # By default, Savon does not use WSSE authentication. Simply specify a username and password to
+  # change this.
+  #
+  #   response = client.get_all_users do |soap, wsse|
+  #     wsse.username = "eve"
+  #     wsse.password = "secret"
+  #   end
+  #
+  # == Digest
+  #
+  # To use WSSE digest authentication, just use the digest method and set it to +true+.
+  #
+  #   response = client.get_all_users do |soap, wsse|
+  #     wsse.username = "eve"
+  #     wsse.password = "secret"
+  #     wsse.digest = true
+  #   end
+  #
+  # == Default to WSSE
+  #
+  # In case all you're services require WSSE authentication, you can set your credentials and whether
+  # to use WSSE digest for every request:
+  #
+  #   Savon::WSSE.username = "eve"
+  #   Savon::WSSE.password = "secret"
+  #   Savon::WSSE.digest = true
+  class WSSE
+
+    # Base address for WSSE docs.
+    BaseAddress = "http://docs.oasis-open.org/wss/2004/01"
+
+    # Namespace for WS Security Secext.
+    WSENamespace = "#{BaseAddress}/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+
+    # Namespace for WS Security Utility.
+    WSUNamespace = "#{BaseAddress}/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+
+    # URI for "wsse:Password/@Type" #PasswordText.
+    PasswordTextURI = "#{BaseAddress}/oasis-200401-wss-username-token-profile-1.0#PasswordText"
+
+    # URI for "wsse:Password/@Type" #PasswordDigest.
+    PasswordDigestURI = "#{BaseAddress}/oasis-200401-wss-username-token-profile-1.0#PasswordDigest"
+
+    # Global WSSE username.
+    @@username = nil
+
+    # Returns the global WSSE username.
+    def self.username
+      @@username
+    end
+
+    # Sets the global WSSE username.
+    def self.username=(username)
+      @@username = username.nil? ? nil : username.to_s
+    end
+
+    # Global WSSE password.
+    @@password = nil
+
+    # Returns the global WSSE password.
+    def self.password
+      @@password
+    end
+
+    # Sets the global WSSE password.
+    def self.password=(password)
+      @@password = password.nil? ? nil : password.to_s
+    end
+
+    # Global setting of whether to use WSSE digest.
+    @@digest = false
+
+    # Returns the global setting of whether to use WSSE digest.
+    def self.digest?
+      @@digest
+    end
+
+    # Global setting of whether to use WSSE digest.
+    def self.digest=(digest)
+      @@digest = digest
+    end
+
+    # Sets the WSSE username per request.
+    def username=(username)
+      @username = username.nil? ? nil : username.to_s
+    end
+
+    # Returns the WSSE username. Defaults to the global setting.
+    def username
+      @username || self.class.username
+    end
+
+    # Sets the WSSE password per request.
+    def password=(password)
+      @password = password.nil? ? nil : password.to_s
+    end
+
+    # Returns the WSSE password. Defaults to the global setting.
+    def password
+      @password || self.class.password
+    end
+
+    # Sets whether to use WSSE digest per request.
+    attr_writer :digest
+
+    # Returns whether to use WSSE digest. Defaults to the global setting.
+    def digest?
+      @digest || self.class.digest?
+    end
+
+    # Returns the XML for a WSSE header or an empty String unless both username and password
+    # were 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, :Type => password_type
+        end
+      end
+    end
+
+  private
+
+    # Returns the WSSE password. Encrypts the password for digest authentication.
+    def password_node
+      return password unless digest?
+
+      token = nonce + timestamp + password
+      Base64.encode64(Digest::SHA1.hexdigest(token)).chomp!
+    end
+
+    # Returns the URI for the "wsse:Password/@Type" attribute.
+    def password_type
+      digest? ? PasswordDigestURI : PasswordTextURI
+    end
+
+    # Returns a WSSE nonce.
+    def nonce
+      @nonce ||= Digest::SHA1.hexdigest String.random + timestamp
+    end
+
+    # Returns a WSSE timestamp.
+    def timestamp
+      @timestamp ||= Time.now.strftime Savon::SOAP::DateTimeFormat
+    end
+
+  end
+end

data/spec/basic_spec_helper.rb

@@ -0,0 +1,11 @@
+require "rake"
+require "spec"
+require "mocha"
+require "fakeweb"
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end
+
+require "savon"
+Savon::Request.log = false

data/spec/endpoint_helper.rb

@@ -0,0 +1,23 @@
+class EndpointHelper
+
+  # Returns the WSDL endpoint for a given +type+ of request.
+  def self.wsdl_endpoint(type = nil)
+    case type
+      when :no_namespace       then "http://nons.example.com/Service?wsdl"
+      when :namespaced_actions then "http://nsactions.example.com/Service?wsdl"
+      when :geotrust           then "https://test-api.geotrust.com/webtrust/query.jws?WSDL"
+      else                          soap_endpoint(type)
+    end
+  end
+
+  # Returns the SOAP endpoint for a given +type+ of request.
+  def self.soap_endpoint(type = nil)
+    case type
+      when :soap_fault then "http://soapfault.example.com/Service?wsdl"
+      when :http_error then "http://httperror.example.com/Service?wsdl"
+      when :invalid    then "http://invalid.example.com/Service?wsdl"
+      else                  "http://example.com/validation/1.0/AuthenticationService"
+    end
+  end
+
+end

data/spec/fixtures/gzip/gzip_response_fixture.rb

@@ -0,0 +1,7 @@
+class GzipResponseFixture
+
+  def self.message
+    File.read(File.join(File.dirname(__FILE__), 'message.gz'))
+  end
+end
+

data/spec/fixtures/response/response_fixture.rb

@@ -0,0 +1,36 @@
+class ResponseFixture
+
+  def self.authentication(value = nil)
+    case value
+      when :to_hash
+        { :success => true,
+          :authentication_value => {
+            :token => "a68d1d6379b62ff339a0e0c69ed4d9cf",
+            :token_hash => "AAAJxA;cIedoT;mY10ExZwG6JuKgp2OYKxow==",
+            :client => "radclient"
+          }
+        }
+      else
+        @@authentication ||= load_fixture :authentication
+    end
+  end
+
+  def self.soap_fault
+    @@soap_fault ||= load_fixture :soap_fault
+  end
+
+  def self.soap_fault12
+    @@soap_fault12 ||= load_fixture :soap_fault12
+  end
+
+  def self.multi_ref
+    @@multi_ref ||= load_fixture :multi_ref
+  end
+
+private
+
+  def self.load_fixture(fixture)
+    File.read File.dirname(__FILE__) + "/xml/#{fixture}.xml"
+  end
+
+end