smacks-savon 0.0.2

data/README.rdoc

@@ -0,0 +1,11 @@
+= Savon
+
+Savon is a lightweight SOAP client.
+
+== Install
+
+  $ sudo gem install smacks-savon --source http://gems.github.com
+
+== Dependencies
+
+  Hpricot 0.6.164 (also available for JRuby)

data/lib/savon.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+$:.unshift(File.join(File.dirname(__FILE__), 'savon'))
+require 'response'
+require 'wsdl'
+require 'service'

data/lib/savon/response.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'apricoteatsgorilla'
+
+module Savon
+
+  # Savon::Response represents the SOAP response and offers different methods
+  # to handle the response.
+  class Response
+
+    # Initializer to set the SOAP response.
+    def initialize(response)
+      @response = response
+    end
+
+    # Returns the SOAP response message as a Hash. Call with XPath expession
+    # (Hpricot search) as parameter to define a custom root node. The root node
+    # itself will not be included in the Hash.
+    def to_hash(root_node = "//return")
+      ApricotEatsGorilla(@response.body, root_node)
+    end
+
+    # Returns the raw XML response.
+    def to_s
+      @response.body
+    end
+
+  end
+end

data/lib/savon/service.rb

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'net/http'
+require 'uri'
+require 'apricoteatsgorilla'
+
+module Savon
+
+  # Savon::Service is the actual SOAP client implementation to use.
+  #
+  # Instantiate Savon::Service and pass in the WSDL of the service you would
+  # like to work with. Then simply call the SOAP service method on your
+  # instance (which will be catched via method_missing) and pass in a Hash
+  # of options you would like to send.
+  #
+  # Example:
+  #   proxy = Savon::Service.new "http://example.com/ExampleService?wsdl"
+  #   response = proxy.findExampleById(:id => "123")
+  #
+  # Get the raw response XML:
+  #   response.to_s
+  #
+  # Get it as a Hash (offers optional XPath expression to set a custom root node):
+  #   response.to_hash
+  #   response.to_hash("//return")
+  #
+  # Or as a Mash object (also offers specifying a custom root node):
+  #   response.to_mash
+  #   response.to_mash("//user/email")
+  class Service
+
+    # Sets the HTTP connection instance.
+    attr_writer :http
+
+    # Initializer sets the endpoint URI.
+    def initialize(endpoint)
+      @uri = URI(endpoint)
+    end
+
+    # Returns an Wsdl instance.
+    def wsdl
+      @wsdl = Savon::Wsdl.new(@uri, http) if @wsdl.nil?
+      @wsdl
+    end
+
+  private
+
+    # Sets up the request headers and body, makes the request and returns a
+    # Savon::Response object.
+    def call_service
+      headers = { 'Content-Type' => 'text/xml; charset=utf-8', 'SOAPAction' => @action }
+      body = ApricotEatsGorilla.soap_envelope("wsdl" => wsdl.namespace_uri) do
+        ApricotEatsGorilla("wsdl:#{@action}" => namespaced_options)
+      end
+      response = @http.request_post(@uri.path, body, headers)
+      Savon::Response.new(response)
+    end
+
+    # Returns an HTTP connection instance.
+    def http
+      if @http.nil?
+        raise ArgumentError, "Invalid endpoint URI" unless @uri.scheme
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+        #@http.set_debug_output(STDOUT)
+        #@http.read_timeout = 5
+      end
+      @http
+    end
+
+    # Checks if the requestion SOAP action is available.
+    # Raises an ArgumentError in case it isn't.
+    def validate_action
+      unless wsdl.service_methods.include? @action
+        raise ArgumentError, "Invalid service method '#{@action}'"
+      end
+    end
+
+    # Checks if there were any choice elements found in the wsdl and namespaces
+    # the corresponding keys from the passed in Hash of options.
+    def namespaced_options
+      return @options if wsdl.choice_elements.empty?
+
+      options = {}
+      @options.each do |key, value|
+        key = "wsdl:#{key}" if wsdl.choice_elements.include? key.to_s
+
+        current = options[key]
+        case current
+        when Array
+          options[key] << value
+        when nil
+          options[key] = value
+        else
+          options[key] = [current.dup, value]
+        end
+      end
+      options
+    end
+
+    # Catches calls to SOAP service methods.
+    def method_missing(method, options = {})
+      @action = method.to_s
+      @options = options
+      validate_action
+      call_service
+    end
+
+  end
+end

data/lib/savon/wsdl.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'net/http'
+require 'hpricot'
+
+module Savon
+
+  # Savon::Wsdl gets, parses and represents the SOAP-WSDL.
+  class Wsdl
+
+    # The namespace URI.
+    attr_reader :namespace_uri
+
+    # Available service methods.
+    attr_reader :service_methods
+
+    # Choice elements.
+    attr_reader :choice_elements
+
+    # Initializer expects an endpoint URI and an HTTP connection instance.
+    # Gets and parses the WSDL at the given URI.
+    def initialize(uri, http)
+      @uri = uri
+      @http = http
+      get_wsdl
+      parse_wsdl
+    end
+
+    # Returns the response body from the WSDL request.
+    def to_s
+      @response.body
+    end
+
+  private
+
+    # Gets the WSDL at the given URI.
+    def get_wsdl
+      @response = @http.get("#{@uri.path}?#{@uri.query}")
+      @doc = Hpricot.XML(@response.body)
+    end
+
+    # Parses the WSDL for the namespace URI, available service methods
+    # and choice elements.
+    def parse_wsdl
+      @namespace_uri = @doc.at('//wsdl:definitions').get_attribute('targetNamespace')
+
+      @service_methods = []
+      @doc.search('//soap:operation').each do |operation|
+        service_methods << operation.parent.get_attribute('name')
+      end
+
+      @choice_elements = []
+      @doc.search('//xs:choice//xs:element').each do |choice|
+        name = choice.get_attribute('ref').sub(/(.+):/, '')
+        choice_elements << name unless @choice_elements.include? name
+      end
+    end
+
+  end
+end

data/tests/factories/wsdl.rb

@@ -0,0 +1,127 @@
+class WsdlFactory
+  attr_accessor :namespace_uri, :service_methods, :choice_elements
+
+  def initialize(new_options = {})
+    options = {
+      :namespace_uri => "http://some.example.com",
+      :service_methods => {"findById" => ["id"]},
+      :choice_elements => {}
+    }.update(new_options)
+
+    @namespace_uri = options[:namespace_uri]
+    @service_methods = options[:service_methods]
+    @choice_elements = options[:choice_elements]
+  end
+
+  def build
+    wsdl = '<wsdl:definitions name="SomeService" targetNamespace="' << namespace_uri << '"
+      xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://example.com"
+      xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+      <wsdl:types>
+        <xs:schema attributeFormDefault="unqualified" elementFormDefault="unqualified"
+          targetNamespace="http://example.com" xmlns:tns="http://example.com"
+          xmlns:xs="http://www.w3.org/2001/XMLSchema">'
+    wsdl << build_elements
+    wsdl << '<xs:element name="result" type="tns:result" />'
+    wsdl << build_complex_types
+    wsdl << '<xs:complexType name="result">
+            <xs:sequence><xs:element name="token" type="xs:token" /></xs:sequence>
+          </xs:complexType>
+        </xs:schema>
+      </wsdl:types>'
+    wsdl << build_messages
+    wsdl << '<wsdl:portType name="SomeWebService">'
+    wsdl << build_operation_input_output
+    wsdl << '</wsdl:portType>
+      <wsdl:binding name="SomeServiceSoapBinding" type="tns:SomeService">
+        <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />'
+    wsdl << build_operation_input_output_body
+    wsdl << '</wsdl:binding>
+      <wsdl:service name="SomeService">
+        <wsdl:port binding="tns:SomeServiceSoapBinding" name="SomeServicePort">
+          <soap:address location="http://example.com/SomeService" />
+        </wsdl:port>
+      </wsdl:service>
+    </wsdl:definitions>'
+  end
+
+  def build_elements
+    wsdl = service_methods.keys.map { |method|
+      '<xs:element name="' << method << '" type="tns:' << method << '" />
+      <xs:element name="' << method << 'Response" type="tns:' << method << 'Response" />'
+    }.to_s
+    wsdl << choice_elements.map { |c_method, c_elements|
+      c_elements.map { |c_element|
+        '<xs:element name="' << c_element << '" type="tns:' << c_element << 'Value" />'
+      }.to_s
+    }.to_s
+    wsdl
+  end
+
+  def build_complex_types
+    service_methods.map { |method, inputs|
+      wsdl = '<xs:complexType name="' << method << '"><xs:sequence>'
+      inputs.each do |input|
+        if choice_elements.keys.include? input
+          wsdl << '<xs:choice>'
+          wsdl << choice_elements[input].map { |element|
+            '<xs:element ref="tns:' << element << '"/>'
+          }.to_s
+          wsdl << '</xs:choice>'
+        else
+          wsdl << '<xs:element minOccurs="0" name="' << input << '" type="xs:string" />'
+        end
+      end
+      wsdl << '</xs:sequence></xs:complexType>'
+      wsdl << build_complex_types_choice_elements
+      wsdl << '<xs:complexType name="' << method << 'Response"><xs:sequence>
+          <xs:element minOccurs="0" name="return" type="tns:result" />
+        </xs:sequence></xs:complexType>'
+    }.to_s
+  end
+
+  def build_complex_types_choice_elements
+    choice_elements.map { |c_method, c_elements|
+        c_elements.map { |c_element|
+          '<xs:complexType name="' << c_element << 'Value"><xs:sequence>
+          <xs:element minOccurs="0" name="' << c_element << '" type="xs:string" />
+          </xs:sequence></xs:complexType>'
+        }.to_s
+      }.to_s
+  end
+
+  def build_messages
+    service_methods.keys.map { |method|
+      '<wsdl:message name="' << method << '">
+        <wsdl:part element="tns:' << method << '" name="parameters"> </wsdl:part>
+      </wsdl:message>
+      <wsdl:message name="' << method << 'Response">
+        <wsdl:part element="tns:' << method << 'Response" name="parameters"> </wsdl:part>
+      </wsdl:message>'
+    }.to_s
+  end
+
+  def build_operation_input_output
+    service_methods.keys.map { |method|
+      '<wsdl:operation name="' << method << '">
+        <wsdl:input message="tns:' << method << '" name="' << method << '"> </wsdl:input>
+        <wsdl:output message="tns:' << method << 'Response" name="' << method << 'Response"> </wsdl:output>
+      </wsdl:operation>'
+    }.to_s
+  end
+
+  def build_operation_input_output_body
+    service_methods.keys.map { |method|
+      '<wsdl:operation name="' << method << '">
+        <soap:operation soapAction="" style="document" />
+        <wsdl:input name="' << method << '">
+          <soap:body use="literal" />
+        </wsdl:input>
+        <wsdl:output name="' << method << 'Response">
+          <soap:body use="literal" />
+        </wsdl:output>
+      </wsdl:operation>'
+    }.to_s
+  end
+
+end

data/tests/fixtures/soap_response.rb

@@ -0,0 +1,15 @@
+module SoapResponseFixture
+
+  def some_soap_response
+    '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+      <soap:Body>
+        <ns2:result xmlns:ns2="http://example.com/">
+          <return>
+            <token>secret</token>
+          </return>
+        </ns2:result>
+      </soap:Body>
+    </soap:Envelope>'
+  end
+
+end

data/tests/helper.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'shoulda'
+require "apricoteatsgorilla"
+
+["service", "wsdl", "response"].each do |file|
+  require File.join(File.dirname(__FILE__), "..", "lib", "savon", file)
+end
+
+require File.join(File.dirname(__FILE__), "factories", "wsdl")
+require File.join(File.dirname(__FILE__), "fixtures", "soap_response")
+
+module TestHelper
+
+  def some_url
+    "http://example.com"
+  end
+
+  def some_uri
+    URI(some_url)
+  end
+
+  def service_http_mock(response_body)
+    http_mock = mock()
+    http_mock.expects(:get).returns(response_mock(WsdlFactory.new.build))
+    http_mock.expects(:request_post).returns(response_mock(response_body))
+    http_mock
+  end
+
+  def http_mock(response_body)
+    http_mock = mock()
+    http_mock.expects(:get).returns(response_mock(response_body))
+    http_mock
+  end
+
+  def response_mock(response_body)
+    response_mock = mock('Net::HTTPResponse')
+    response_mock.stubs(
+      :code => '200', :message => "OK", :content_type => "text/html",
+      :body => response_body
+    )
+    response_mock
+  end
+
+end

data/tests/savon/response_test.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+require File.join(File.dirname(__FILE__), "..", "helper")
+
+class SavonResponseTest < Test::Unit::TestCase
+
+  include TestHelper
+  include SoapResponseFixture
+
+  context "Savon::Response with some SOAP response" do
+    setup do
+      ApricotEatsGorilla.sort_keys = true
+      @response = Savon::Response.new(response_mock(some_soap_response))
+    end
+
+    should "return a Hash on to_hash" do
+      assert_kind_of Hash, @response.to_hash
+    end
+
+    should "return a Hash equal to the response on to_hash" do
+      assert_equal ApricotEatsGorilla(some_soap_response, "//return"), @response.to_hash
+    end
+
+    should "return the raw XML response on to_s" do
+      assert_equal some_soap_response, @response.to_s
+    end
+  end
+
+end

data/tests/savon/service_test.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+require File.join(File.dirname(__FILE__), "..", "helper")
+
+class SavonServiceTest < Test::Unit::TestCase
+
+  include TestHelper
+  include SoapResponseFixture
+
+  context "Savon::Service" do
+    setup do
+      @service = Savon::Service.new(some_url)
+      @service.http = service_http_mock(some_soap_response)
+      @result = @service.findById
+    end
+
+    should "return a Savon::Response object containing the given response" do
+      assert_kind_of Savon::Response, @result
+      assert_equal some_soap_response, @result.to_s
+    end
+
+    should "return an instance of Savon::Wsdl on wsdl" do
+      assert_kind_of Savon::Wsdl, @service.wsdl
+    end
+
+    should "raise an ArgumentError when called with an invalid action" do
+      assert_raise ArgumentError do
+        @service.somethingCrazy
+      end
+    end
+  end
+
+end

data/tests/savon/wsdl_test.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+require File.join(File.dirname(__FILE__), "..", "helper")
+
+class SavonWsdlTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  context "Savon::Wsdl without choice elements" do
+    setup do
+      @some_factory = WsdlFactory.new
+      @some_wsdl = Savon::Wsdl.new(some_uri, http_mock(@some_factory.build))
+    end
+
+    should "return the namespace_uri" do
+      assert_equal @some_factory.namespace_uri, @some_wsdl.namespace_uri
+    end
+
+    should "return the available service_methods" do
+       assert_equal @some_factory.service_methods.keys, @some_wsdl.service_methods
+    end
+
+    should "not find any choice elements, so choice_elements returns []" do
+      assert_equal @some_factory.choice_elements.keys, @some_wsdl.choice_elements
+    end
+  end
+
+  context "Savon::Wsdl with choice elements" do
+    setup do
+      @choice_factory = WsdlFactory.new(
+        :service_methods => {"findUser" => ["credential"]},
+        :choice_elements => {"credential" => ["id", "email"]}
+      )
+      @choice_wsdl = Savon::Wsdl.new(some_uri, http_mock(@choice_factory.build))
+    end
+
+    should "return the available choice elements" do
+      assert_equal @choice_factory.choice_elements["credential"], @choice_wsdl.choice_elements
+    end
+
+    should "return the raw SOAP response on to_s" do
+      assert_equal @choice_factory.build, @choice_wsdl.to_s
+    end
+  end
+
+end

data/tests/savon_test.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+$:.unshift(File.join(File.dirname(__FILE__), 'savon'))
+require "service_test"
+require "wsdl_test"
+require "response_test"

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: smacks-savon
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Daniel Harrington
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.6.164
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: smacks-apricoteatsgorilla
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.6
+    version: 
+description: Savon is a lightweight SOAP client.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- lib/savon.rb
+- lib/savon/service.rb
+- lib/savon/wsdl.rb
+- lib/savon/response.rb
+has_rdoc: true
+homepage: http://github.com/smacks/savon
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- mocha for testing
+- shoulda for testing
+- apricoteatsgorilla for testing
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Savon is a lightweight SOAP client.
+test_files: 
+- tests/savon_test.rb
+- tests/helper.rb
+- tests/factories/wsdl.rb
+- tests/fixtures/soap_response.rb
+- tests/savon/service_test.rb
+- tests/savon/wsdl_test.rb
+- tests/savon/response_test.rb