tictoc-savon 0.7.9

data/spec/savon/core_ext/net_http_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Net::HTTP do
+  before do
+    @some_uri = URI "http://example.com"
+    @another_uri = URI "http://example.org"
+    @http = Net::HTTP.new @some_uri.host, @some_uri.port
+  end
+
+  describe "endpoint" do
+    it "changes the address and port of a Net::HTTP object" do
+      @http.address.should == @some_uri.host
+      @http.port.should == @some_uri.port
+
+      @http.endpoint @another_uri.host, @another_uri.port
+      @http.address.should == @another_uri.host
+      @http.port.should == @another_uri.port
+    end
+  end
+
+  describe "ssl_client_auth" do
+    it "accepts a Hash of options for SSL client authentication" do
+      @http.cert.should be_nil
+      @http.key.should be_nil
+      @http.ca_file.should be_nil
+      @http.verify_mode.should be_nil
+
+      @http.ssl_client_auth :cert => "cert", :key => "key",
+        :ca_file => "ca_file", :verify_mode => OpenSSL::SSL::VERIFY_PEER
+
+      @http.cert.should == "cert"
+      @http.key.should == "key"
+      @http.ca_file.should == "ca_file"
+      @http.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+    end
+  end
+
+end

data/spec/savon/core_ext/object_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Object do
+
+  describe "blank?" do
+    it "returns true for Objects perceived to be blank" do
+      ["", false, nil, [], {}].each do |object|
+        object.should be_blank
+      end
+    end
+
+    it "returns false for every other Object" do
+      ["!blank", true, [:a], {:a => "b"}].each do |object|
+        object.should_not be_blank
+      end
+    end
+  end
+
+  describe "to_soap_value" do
+    it "returns an xs:dateTime compliant String for Objects responding to to_datetime" do
+      singleton = Object.new
+      def singleton.to_datetime
+        DateTime.new(2012, 03, 22, 16, 22, 33)
+      end
+
+      singleton.to_soap_value.should == "2012-03-22T16:22:33Z"
+    end
+
+    it "calls to_s unless the Object responds to to_datetime" do
+      "value".to_soap_value.should == "value".to_s
+    end
+  end
+
+end

data/spec/savon/core_ext/string_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+describe String do
+
+  describe "self.random" do
+    it "returns a random 100-character String" do
+      String.random.should be_a(String)
+      String.random.length.should == 100
+    end
+
+    it "returns a random String of a given length" do
+      String.random(50).should be_a(String)
+      String.random(50).length.should == 50
+    end
+  end
+
+  describe "snakecase" do
+    it "converts a lowerCamelCase String to snakecase" do
+      "lowerCamelCase".snakecase.should == "lower_camel_case"
+    end
+
+    it "converts period characters to underscores" do
+      "User.GetEmail".snakecase.should == "user_get_email"
+    end
+  end
+
+  describe "lower_camelcase" do
+    it "converts a snakecase String to lowerCamelCase" do
+      "lower_camel_case".lower_camelcase.should == "lowerCamelCase"
+    end
+  end
+
+  describe "starts_with?" do
+    it "should return whether it starts with a given suffix" do
+      "authenticate".starts_with?("auth").should be_true
+      "authenticate".starts_with?("cate").should be_false
+    end
+  end
+
+  describe "ends_with?" do
+    it "should return whether it ends with a given suffix" do
+      "authenticate!".ends_with?("!").should be_true
+      "authenticate".ends_with?("cate").should be_true
+      "authenticate".ends_with?("?").should be_false
+    end
+  end
+
+  describe "strip_namespace" do
+    it "strips the namespace from a namespaced String" do
+      "ns:customer".strip_namespace.should == "customer"
+    end
+
+    it "returns the original String for a String without namespace" do
+      "customer".strip_namespace.should == "customer"
+    end
+  end
+
+  describe "map_soap_response" do
+    it "returns a DateTime Object for Strings matching the xs:dateTime format" do
+      "2012-03-22T16:22:33".map_soap_response.should ==
+        DateTime.new(2012, 03, 22, 16, 22, 33)
+    end
+
+    it "returns true for Strings matching 'true'" do
+      "true".map_soap_response.should be_true
+    end
+
+    it "returns false for Strings matching 'false'" do
+      "false".map_soap_response.should be_false
+    end
+
+    it "defaults to return the original value" do
+      "whatever".map_soap_response.should == "whatever"
+    end
+  end
+
+  describe "to_soap_key" do
+    it "removes exclamation marks from the end of the String" do
+      "value".to_soap_key.should == "value"
+      "value!".to_soap_key.should == "value"
+    end
+  end
+
+  describe "to_soap_value" do
+    it "should return the String value and escape special characters" do
+      "string".to_soap_value.should == "string"
+      "<tag>".to_soap_value.should == "&lt;tag&gt;"
+      "at&t".to_soap_value.should == "at&amp;t"
+      '"quotes"'.to_soap_value.should == "&quot;quotes&quot;"
+    end
+  end
+
+  describe "to_soap_value!" do
+    it "should just return the String value without escaping special characters" do
+      "<tag>".to_soap_value!.should == "<tag>"
+    end
+  end
+
+end

data/spec/savon/core_ext/symbol_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Symbol do
+
+  describe "to_soap_key" do
+    it "converts the Symbol from snake_case to a lowerCamelCase String" do
+      :lower_camel_case.to_soap_key.should == "lowerCamelCase"
+      :lower_camel_case!.to_soap_key.should == "lowerCamelCase"
+    end
+  end
+
+end

data/spec/savon/core_ext/uri_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe URI::HTTP do
+
+  describe "ssl?" do
+    it "returns true for https URI's" do
+      URI("https://example.com").ssl?.should be_true
+    end
+
+    it "returns false for non-https URI's" do
+      URI("http://example.com").ssl?.should be_false
+    end
+
+    it "returns nil for invalid URI's without a scheme" do
+      URI("example").ssl?.should be_nil
+    end
+  end
+
+end

data/spec/savon/request_spec.rb

@@ -0,0 +1,117 @@
+require "spec_helper"
+
+describe Savon::Request do
+  before { @request = Savon::Request.new EndpointHelper.wsdl_endpoint }
+
+  it "contains the ContentType for each supported SOAP version" do
+    content_type = { 1 => "text/xml;charset=UTF-8", 2 => "application/soap+xml;charset=UTF-8" }
+    content_type.each { |version, type| Savon::Request::ContentType[version].should == type }
+  end
+
+  # defaults to log request and response. disabled for spec execution
+
+  it "has both getter and setter for whether to log (global setting)" do
+    Savon::Request.log = true
+    Savon::Request.log?.should be_true
+    Savon::Request.log = false
+    Savon::Request.log?.should be_false
+  end
+
+  it "defaults to use a Logger instance for logging" do
+    Savon::Request.logger.should be_a(Logger)
+  end
+
+  it "has both getter and setter for the logger to use (global setting)" do
+    Savon::Request.logger = {}
+    Savon::Request.logger.should be_a(Hash)
+    Savon::Request.logger = Logger.new STDOUT
+  end
+
+  it "defaults to :debug for logging" do
+    Savon::Request.log_level.should == :debug
+  end
+
+  it "has both getter and setter for the log level to use (global setting)" do
+    Savon::Request.log_level = :info
+    Savon::Request.log_level.should == :info
+    Savon::Request.log_level = :debug
+  end
+
+  it "is initialized with a SOAP endpoint String" do
+    Savon::Request.new EndpointHelper.wsdl_endpoint
+  end
+
+  it "has a getter for the SOAP endpoint URI" do
+    @request.endpoint.should == URI(EndpointHelper.wsdl_endpoint)
+  end
+
+  it "should have a getter for the proxy URI" do
+    @request.proxy.should == URI("")
+  end
+
+  it "should have a getter for the HTTP headers which defaults to an empty Hash" do
+    @request.headers.should == {}
+  end
+
+  it "should have a setter for the HTTP headers" do
+    headers = { "some" => "thing" }
+
+    @request.headers = headers
+    @request.headers.should == headers
+  end
+
+  it "should return the Net::HTTP object" do
+    @request.http.should be_kind_of(Net::HTTP)
+  end
+
+  it "should have a method for setting HTTP basic auth credentials" do
+    @request.basic_auth "user", "password"
+  end
+
+  it "retrieves the WSDL document and returns the Net::HTTP response" do
+    wsdl_response = @request.wsdl
+
+    wsdl_response.should be_a(Net::HTTPResponse)
+    wsdl_response.body.should == WSDLFixture.authentication
+  end
+
+
+  describe "when executing a SOAP request" do
+    before :each do
+      operation = WSDLFixture.authentication(:operations)[:authenticate]
+      action, input = operation[:action], operation[:input]
+      @soap = Savon::SOAP.new action, input, EndpointHelper.soap_endpoint
+    end
+
+    it "should return the Net::HTTP response" do
+      soap_response = @request.soap @soap
+
+      soap_response.should be_a(Net::HTTPResponse)
+      soap_response.body.should == ResponseFixture.authentication
+    end
+
+    it "should include Accept-Encoding gzip if it is enabled" do
+      @request = Savon::Request.new EndpointHelper.wsdl_endpoint, :gzip => true
+      a_post = Net::HTTP::Post.new(@soap.endpoint.request_uri, {})
+
+      Net::HTTP::Post.expects(:new).with(anything, has_entry("Accept-encoding" => "gzip,deflate")).returns(a_post)
+
+      @request.soap @soap
+    end
+
+    it "should not include Accept-Encoding gzip if it is not enabled" do
+      @request = Savon::Request.new EndpointHelper.wsdl_endpoint, :gzip => false
+      a_post = Net::HTTP::Post.new(@soap.endpoint.request_uri, {})
+
+      Net::HTTP::Post.expects(:new).with(anything, Not(has_entry("Accept-encoding" => "gzip,deflate"))).returns(a_post)
+
+      @request.soap @soap
+    end
+  end
+
+  it "should not include host when creating HTTP requests" do
+    request = @request.send(:request, :wsdl)
+    request.path.should_not include("example.com")
+  end
+
+end

data/spec/savon/response_spec.rb

@@ -0,0 +1,179 @@
+require "spec_helper"
+
+describe Savon::Response do
+  before { @response = Savon::Response.new http_response_mock }
+
+  it "defaults to raises both Savon::SOAPFault and Savon::HTTPError" do
+    Savon::Response.raise_errors?.should be_true
+  end
+
+  it "has both getter and setter for whether to raise errors (global setting)" do
+    Savon::Response.raise_errors = false
+    Savon::Response.raise_errors?.should == false
+    Savon::Response.raise_errors = true
+  end
+
+  describe "initialize" do
+    it "expects a Net::HTTPResponse" do
+      Savon::Response.new http_response_mock
+    end
+
+    it "raises a Savon::SOAPFault in case of a SOAP fault" do
+      lambda { savon_response_with :soap_fault }.should raise_error(Savon::SOAPFault)
+    end
+
+    it "does not raise a Savon::SOAPFault in case the default is turned off" do
+      Savon::Response.raise_errors = false
+      savon_response_with :soap_fault
+      Savon::Response.raise_errors = true
+    end
+
+    it "raises a Savon::HTTPError in case of an HTTP error" do
+      lambda { savon_response_with :http_error }.should raise_error(Savon::HTTPError)
+    end
+
+    it "does not raise a Savon::HTTPError in case the default is turned off" do
+      Savon::Response.raise_errors = false
+      savon_response_with :http_error
+      Savon::Response.raise_errors = true
+    end
+  end
+
+  describe "soap_fault?" do
+    before { Savon::Response.raise_errors = false }
+
+    it "does not return true in case the response seems to be ok" do
+      @response.soap_fault?.should_not be_true
+    end
+
+    it "returns true in case of a SOAP fault" do
+      savon_response_with(:soap_fault).soap_fault?.should be_true
+    end
+
+    after { Savon::Response.raise_errors = true }
+  end
+
+  describe "soap_fault" do
+    before { Savon::Response.raise_errors = false }
+
+    it "returns the SOAP fault message in case of a SOAP fault" do
+      savon_response_with(:soap_fault).soap_fault.
+        should == "(soap:Server) Fault occurred while processing."
+    end
+
+    it "returns the SOAP fault message in case of a SOAP 1.2 fault" do
+      savon_response_with(:soap_fault12).soap_fault.
+        should == "(soap:Sender) Sender Timeout"
+    end
+
+    after { Savon::Response.raise_errors = true }
+  end
+
+  describe "http_error?" do
+    before { Savon::Response.raise_errors = false }
+
+    it "does not return true in case the response seems to be ok" do
+      @response.http_error?.should_not be_true
+    end
+
+    it "returns true in case of an HTTP error" do
+      savon_response_with(:http_error).http_error?.should be_true
+    end
+
+    after { Savon::Response.raise_errors = true }
+  end
+
+  describe "http_error" do
+    before { Savon::Response.raise_errors = false }
+
+    it "returns the HTTP error message in case of an HTTP error" do
+      savon_response_with(:http_error).http_error.should == "Not found (404)"
+    end
+
+    after { Savon::Response.raise_errors = true }
+  end
+
+  it "should return the SOAP response body as a Hash" do
+    @response.to_hash[:authenticate_response][:return].should ==
+      ResponseFixture.authentication(:to_hash)
+  end
+
+  it "should return a Hash for a SOAP multiRef response" do
+    @response = Savon::Response.new http_response_mock(200, ResponseFixture.multi_ref, "OK")
+
+    @response.to_hash[:list_response].should be_a(Hash)
+    @response.to_hash[:multi_ref].should be_an(Array)
+  end
+
+  it "should return the raw SOAP response body" do
+    @response.to_xml.should == ResponseFixture.authentication
+    @response.to_s.should == ResponseFixture.authentication
+  end
+
+  it "should return the Net::HTTP response object" do
+    @response.http.should be_a(Mocha::Mock)
+    @response.http.should respond_to(:code)
+    @response.http.should respond_to(:message)
+    @response.http.should respond_to(:body)
+  end
+
+  describe "GZipped responses" do
+    it "should be decoded if Content-encoding header is gzip" do
+      @response = Savon::Response.new http_response_mock(200, body = "Encoded", "OK", 'content-encoding' => 'gzip')
+
+      should_decode_body body
+
+      @response.to_xml
+    end
+
+    # header logic extracted from http://dev.ctor.org/svn/soap4r/trunk/lib/soap/streamHandler.rb
+    it "should be decoded if body starts with gzip header" do
+      @response = Savon::Response.new http_response_mock(200, body = "\x1f\x8bEncoded", "OK")
+
+      should_decode_body body
+
+      @response.to_xml
+    end
+
+    it "should be decoded when header is set" do
+      @response = Savon::Response.new http_response_mock(200, GzipResponseFixture.message, "OK", 'content-encoding' => 'gzip')
+      @response.to_xml.should == "A short gzip encoded message\n"
+    end
+
+    it "should be decoded when header is not set" do
+      @response = Savon::Response.new http_response_mock(200, GzipResponseFixture.message, "OK")
+      @response.to_xml.should == "A short gzip encoded message\n"
+    end
+  end
+
+  def should_decode_body(body)
+    StringIO.expects(:new).with(body).returns(stream = mock("StringIO"))
+
+    Zlib::GzipReader.expects(:new).with(stream).returns(mock("Zlib::GzipReader") do
+      expects(:read)
+      expects(:close)
+    end)
+  end
+
+  def savon_response_with(error_type)
+    mock = case error_type
+      when :soap_fault   then http_response_mock 200, ResponseFixture.soap_fault
+      when :soap_fault12 then http_response_mock 200, ResponseFixture.soap_fault12
+      when :http_error   then http_response_mock 404, "", "Not found"
+    end
+    Savon::Response.new mock
+  end
+
+  def http_response_mock(code = 200, body = nil, message = "OK", headers = {})
+    body ||= ResponseFixture.authentication
+    mock = mock "Net::HTTPResponse"
+    mock.stubs :code => code.to_s, :message => message, :content_type => "text/html", :body => body
+
+    mock.stubs("[]").with(anything).returns(nil)
+    headers.each { |key, value| mock.stubs("[]").with(key).returns(value) }
+
+    mock
+  end
+
+end
+