savon 0.7.9 → 0.8.0.beta.1

data/spec/integration/http_basic_auth_spec.rb

@@ -1,16 +0,0 @@
-require "basic_spec_helper"
-
-describe Savon do
-  before { @client = Savon::Client.new "http://localhost:8080/http-basic-auth" }
-
-  it "should be able to handle HTTP basic authentication" do
-    @client.request.basic_auth "user", "password"
-    response = @client.do_something!
-    response.to_hash[:authenticate_response][:return][:success].should == true
-  end
-
-  it "should raise a Savon::HTTPError in case authentication failed" do
-    lambda { @client.do_something! }.should raise_error(Savon::HTTPError)
-  end
-
-end

data/spec/integration/server.rb

@@ -1,51 +0,0 @@
-require "webrick"
-
-include WEBrick
-
-# Run WEBrick. Yields the server to a given block.
-def run_webrick(config = {})
-  config.update :Port => 8080
-  server = HTTPServer.new config
-  yield server if block_given?
-  ["INT", "TERM"].each { |signal| trap(signal) { server.shutdown } }
-  server.start
-end
-
-# Returns the SOAP response fixture for a given +file+.
-def respond_with(file)
-  response_path = File.dirname(__FILE__) + "/../fixtures/response/xml"
-  File.read "#{response_path}/#{file}.xml"
-end
-
-# Returns HTML links for a given Hash of link URI's and names.
-def link_to(links)
-  links.map { |link| "<a href='#{link[:uri]}'>#{link[:name]}</a>" }.join("<br>")
-end
-
-run_webrick do |server|
-  user, password, realm = "user", "password", "realm"
-
-  htdigest = HTTPAuth::Htdigest.new "/tmp/webrick-htdigest"
-  htdigest.set_passwd realm, user, password
-  authenticator = HTTPAuth::DigestAuth.new :UserDB => htdigest, :Realm => realm
-
-  # Homepage including links to subpages.
-  server.mount_proc("/") do |request, response|
-    response.body = link_to [
-      { :uri => "http-basic-auth", :name => "HTTP basic auth" },
-      { :uri => "http-digest-auth", :name => "HTTP digest auth" }
-    ]
-  end
-
-  # HTTP basic authentication.
-  server.mount_proc("/http-basic-auth") do |request, response|
-    HTTPAuth.basic_auth(request, response, realm) { |u, p| u == user && p == password }
-    response.body = respond_with :authentication
-  end
-
-  # HTTP digest authentication.
-  server.mount_proc("/http-digest-auth") do |request, response|
-    authenticator.authenticate request, response
-    response.body = "HTTP digest authentication successfull"
-  end
-end

data/spec/savon/core_ext/net_http_spec.rb

@@ -1,38 +0,0 @@
-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/uri_spec.rb

@@ -1,19 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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
-

data/spec/spec.opts

@@ -1,4 +0,0 @@
---colour
---format progress
---loadby mtime
---reverse