savon 1.2.0 → 2.0.0

data/spec/savon/config_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-
-describe Savon::Config do
-
-  let(:config) {
-    config = Savon::Config.new
-    config._logger = Savon::Logger.new
-    config
-  }
-
-  describe "#clone" do
-    it "clones the logger" do
-      logger = config.logger
-      clone = config.clone
-
-      logger.should_not equal(clone.logger)
-    end
-  end
-
-  it "allows to change the logger" do
-    logger = Logger.new("/dev/null")
-    config.logger = logger
-    config._logger.subject.should equal(logger)
-  end
-
-  it "allows to change the log level" do
-    config.log_level = :info
-    config._logger.level.should == :info
-  end
-
-  it "allows to enable/disable logging" do
-    config.log = false
-    config._logger.should be_a(Savon::NullLogger)
-    config.log = true
-    config._logger.should be_a(Savon::Logger)
-  end
-
-end

data/spec/savon/hooks/group_spec.rb

@@ -1,71 +0,0 @@
-require "spec_helper"
-
-describe Savon::Hooks::Group do
-
-  let(:group) { subject }
-
-  describe "#empty?" do
-    it "returns true for an empty group" do
-      group.should be_empty
-    end
-
-    it "returns false if the group contains hooks" do
-      group = Savon::Hooks::Group.new [:some_hook]
-      group.should_not be_empty
-    end
-  end
-
-  describe "#define" do
-    it "lets you define a new hook" do
-      group.define(:test_hook, :soap_request)
-      group.should_not be_empty
-    end
-
-    it "raises if there is no such hook" do
-      expect { group.define(:supposed_to_fail, :no_such_hook) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#reject" do
-    it "rejects hooks matching any given id" do
-      group.define(:remove1, :soap_request)
-      group.define(:here_to_stay, :soap_request)
-      group.define(:remove2, :soap_request)
-      group.count.should == 3
-
-      group.reject(:remove1, :remove2)
-      group.count.should == 1
-    end
-  end
-
-  describe "#fire" do
-    let(:hook)     { lambda {} }
-    let(:fallback) { lambda {} }
-
-    context "with hooks" do
-      before do
-        group.define(:some_hook, :soap_request, &hook)
-      end
-
-      it "calls the hooks passing any arguments" do
-        hook.expects(:call).with(:arg1, :arg2)
-        group.fire(:soap_request, :arg1, :arg2)
-      end
-
-      it "calls the hooks passing any arguments and the callback" do
-        hook.expects(:call).with(fallback, :arg)
-        group.fire(:soap_request, :arg, &fallback)
-      end
-    end
-
-    context "without hooks" do
-      it "executes the callback" do
-        report = :call
-        fallback = lambda { report = :back }
-        group.fire(:soap_request, &fallback)
-        report.should == :back
-      end
-    end
-  end
-
-end

data/spec/savon/hooks/hook_spec.rb

@@ -1,16 +0,0 @@
-require "spec_helper"
-
-describe Savon::Hooks::Hook do
-
-  let(:hook) { lambda {} }
-
-  describe "#call" do
-    it "calls the hook" do
-      hook = Savon::Hooks::Hook.new(:my_hook, :soap_request, &hook)
-      hook.expects(:call).with(:arg1, :arg2)
-
-      hook.call(:arg1, :arg2)
-    end
-  end
-
-end

data/spec/savon/http/error_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-describe Savon::HTTP::Error do
-  let(:http_error) { Savon::HTTP::Error.new new_response(:code => 404, :body => "Not Found") }
-  let(:no_error) { Savon::HTTP::Error.new new_response }
-
-  it "should be a Savon::Error" do
-    Savon::HTTP::Error.should < Savon::Error
-  end
-
-  describe "#http" do
-    it "should return the HTTPI::Response" do
-      http_error.http.should be_an(HTTPI::Response)
-    end
-  end
-
-  describe "#present?" do
-    it "should return true if there was an HTTP error" do
-      http_error.should be_present
-    end
-
-    it "should return false unless there was an HTTP error" do
-      no_error.should_not be_present
-    end
-  end
-
-  [:message, :to_s].each do |method|
-    describe "##{method}" do
-      it "should return an empty String unless an HTTP error is present" do
-        no_error.send(method).should == ""
-      end
-
-      it "should return the HTTP error message" do
-        http_error.send(method).should == "HTTP error (404): Not Found"
-      end
-    end
-  end
-
-  describe "#to_hash" do
-    it "should return the HTTP response details as a Hash" do
-      http_error.to_hash.should == { :code => 404, :headers => {}, :body => "Not Found" }
-    end
-  end
-
-  def new_response(options = {})
-    defaults = { :code => 200, :headers => {}, :body => Fixture.response(:authentication) }
-    response = defaults.merge options
-
-    HTTPI::Response.new response[:code], response[:headers], response[:body]
-  end
-
-end

data/spec/savon/logger_spec.rb

@@ -1,51 +0,0 @@
-require "spec_helper"
-
-describe Savon::Logger do
-
-  let(:logger)                  { subject }
-  let(:message)                 { "<?xml version='1.0'?><hello>world</hello>" }
-  let(:pretty_message)          { Nokogiri::XML(message) }
-  let(:filtered_message)        { Nokogiri::XML("<?xml version='1.0'?><hello>***FILTERED***</hello>") }
-
-  it "logs a given message" do
-    logger.subject.expects(logger.level).with(message)
-    logger.log(message)
-  end
-
-  it "logs a given message (pretty)" do
-    logger.subject.expects(logger.level).with(pretty_message.to_xml(:indent => 2))
-    logger.log(message, :pretty => true)
-  end
-
-  it "logs a given message (filtered)" do
-    logger.subject.expects(logger.level).with(filtered_message.to_s)
-    logger.filter << :hello
-    warn logger.log(message, :filter => true)
-  end
-
-  it "logs a given message (pretty and filtered)" do
-    logger.subject.expects(logger.level).with(filtered_message.to_xml(:indent => 2))
-    logger.filter << :hello
-    logger.log(message, :pretty => true, :filter => true)
-  end
-
-  it "defaults to wrap the standard Logger" do
-    logger.subject.should be_a(Logger)
-  end
-
-  it "can be configured to use a different Logger" do
-    MyLogger = Object.new
-    logger.subject = MyLogger
-    logger.subject.should == MyLogger
-  end
-
-  it "defaults to the :debug log level" do
-    logger.level.should == :debug
-  end
-
-  it "can be configured to use a different log level" do
-    logger.level = :info
-    logger.level.should == :info
-  end
-
-end

data/spec/savon/savon_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Savon do
-
-  it "provides a shortcut for creating a new client" do
-    Savon.client("http://example.com").should be_a(Savon::Client)
-  end
-
-  it "memoizes the global config" do
-    Savon.config.should equal(Savon.config)
-  end
-
-  it "yields the global config to a block" do
-    Savon.configure do |config|
-      config.should equal(Savon.config)
-    end
-  end
-
-  describe ".config" do
-    it "defaults to a log facade" do
-      Savon.config.logger.should be_a(Savon::Logger)
-    end
-
-    it "defaults to raise errors" do
-      Savon.config.raise_errors.should be_true
-    end
-
-    it "defaults to SOAP 1.1" do
-      Savon.config.soap_version.should == 1
-    end
-  end
-
-end

data/spec/savon/soap/fault_spec.rb

@@ -1,89 +0,0 @@
-require "spec_helper"
-
-describe Savon::SOAP::Fault do
-  let(:soap_fault) { Savon::SOAP::Fault.new new_response(:body => Fixture.response(:soap_fault)) }
-  let(:soap_fault2) { Savon::SOAP::Fault.new new_response(:body => Fixture.response(:soap_fault12)) }
-  let(:another_soap_fault) { Savon::SOAP::Fault.new new_response(:body => Fixture.response(:another_soap_fault)) }
-  let(:no_fault) { Savon::SOAP::Fault.new new_response }
-
-  it "should be a Savon::Error" do
-    Savon::SOAP::Fault.should < Savon::Error
-  end
-
-  describe "#http" do
-    it "should return the HTTPI::Response" do
-      soap_fault.http.should be_an(HTTPI::Response)
-    end
-  end
-
-  describe "#present?" do
-    it "should return true if the HTTP response contains a SOAP 1.1 fault" do
-      soap_fault.should be_present
-    end
-
-    it "should return true if the HTTP response contains a SOAP 1.2 fault" do
-      soap_fault2.should be_present
-    end
-
-    it "should return true if the HTTP response contains a SOAP fault with different namespaces" do
-      another_soap_fault.should be_present
-    end
-
-    it "should return false unless the HTTP response contains a SOAP fault" do
-      no_fault.should_not be_present
-    end
-  end
-
-  [:message, :to_s].each do |method|
-    describe "##{method}" do
-      it "should return an empty String unless a SOAP fault is present" do
-        no_fault.send(method).should == ""
-      end
-
-      it "should return a SOAP 1.1 fault message" do
-        soap_fault.send(method).should == "(soap:Server) Fault occurred while processing."
-      end
-
-      it "should return a SOAP 1.2 fault message" do
-        soap_fault2.send(method).should == "(soap:Sender) Sender Timeout"
-      end
-
-      it "should return a SOAP fault message (with different namespaces)" do
-        another_soap_fault.send(method).should == "(ERR_NO_SESSION) Wrong session message"
-      end
-    end
-  end
-
-  describe "#to_hash" do
-    it "should return the SOAP response as a Hash unless a SOAP fault is present" do
-      no_fault.to_hash[:authenticate_response][:return][:success].should be_true
-    end
-
-    it "should return a SOAP 1.1 fault as a Hash" do
-      soap_fault.to_hash.should == {
-        :fault => {
-          :faultstring => "Fault occurred while processing.",
-          :faultcode   => "soap:Server"
-        }
-      }
-    end
-
-    it "should return a SOAP 1.2 fault as a Hash" do
-      soap_fault2.to_hash.should == {
-        :fault => {
-          :detail => { :max_time => "P5M" },
-          :reason => { :text => "Sender Timeout" },
-          :code   => { :value => "soap:Sender", :subcode => { :value => "m:MessageTimeout" } }
-        }
-      }
-    end
-  end
-
-  def new_response(options = {})
-    defaults = { :code => 500, :headers => {}, :body => Fixture.response(:authentication) }
-    response = defaults.merge options
-
-    HTTPI::Response.new response[:code], response[:headers], response[:body]
-  end
-
-end

data/spec/savon/soap/request_builder_spec.rb

@@ -1,207 +0,0 @@
-require "spec_helper"
-
-describe Savon::SOAP::RequestBuilder do
-  describe "#request" do
-    def build_request_builder(operation)
-      request_builder = Savon::SOAP::RequestBuilder.new(operation)
-
-      request_builder.wsdl.document = Fixture.wsdl(:authentication)
-      request_builder.soap = soap
-      request_builder.http = http
-      request_builder.config = config
-      request_builder.wsse = wsse
-
-      soap.stubs(:types).returns({})
-      http.stubs(:headers).returns({})
-
-      request_builder
-    end
-
-    let(:soap) { stub_everything('soap') }
-    let(:http) { stub_everything('http') }
-    let(:config) { stub_everything('config') }
-    let(:wsse) { stub_everything('wsse') }
-    let(:request_builder) { build_request_builder(:get_user) }
-
-    before do
-      Savon::SOAP::Request.stubs(:new).returns(stub_everything('request'))
-    end
-
-    describe "the configuration of dependencies" do
-      it "sets the SOAP endpoint to the endpoint specified by the WSDL document" do
-        endpoint = request_builder.wsdl.endpoint
-        request_builder.wsdl.expects(:endpoint).returns(endpoint)
-        soap.expects(:endpoint=).with(endpoint)
-
-        request_builder.request
-      end
-
-      it "sets the SOAP element form default to the element form default specified by the WSDL document" do
-        element_form_default = request_builder.wsdl.element_form_default
-        request_builder.wsdl.expects(:element_form_default).returns(element_form_default)
-        soap.expects(:element_form_default=).with(element_form_default)
-
-        request_builder.request
-      end
-
-      it "sets the SOAP WSSE property to the WSSE property of the request builder" do
-        soap.expects(:wsse=).with(wsse)
-
-        request_builder.request
-      end
-
-      it "sets the SOAP namespace to the namespace specified by the WSDL document" do
-        namespace = "http://v1_0.ws.auth.order.example.com/"
-        soap.expects(:namespace=).with(namespace)
-
-        request_builder.request
-      end
-
-      it "sets the SOAP namespace identifier to nil" do
-        namespace_identifier = nil
-        soap.expects(:namespace_identifier=).with(namespace_identifier)
-
-        request_builder.request
-      end
-
-      it "sets the SOAP input to result in <getUser>" do
-        soap_input = [nil, :getUser, {}]
-        soap.expects(:input=).with(soap_input)
-
-        request_builder.request
-      end
-
-      context "when the operation namespace is specified by the WSDL" do
-        before do
-          request_builder.wsdl.operations[:authenticate][:namespace_identifier] = "tns"
-        end
-
-        let(:request_builder) { build_request_builder(:authenticate) }
-
-        it "sets the SOAP namespace to the operation's namespace" do
-          namespace = "http://v1_0.ws.auth.order.example.com/"
-          soap.expects(:namespace=).with(namespace)
-
-          request_builder.request
-        end
-
-        it "sets the SOAP namespace identifier to the operation's namespace identifier" do
-          namespace_identifier = :tns
-          soap.expects(:namespace_identifier=).with(namespace_identifier)
-
-          request_builder.request
-        end
-
-        it "sets the SOAP input to include the namespace identifier" do
-          soap_input = [:tns, :authenticate, {}]
-          soap.expects(:input=).with(soap_input)
-
-          request_builder.request
-        end
-      end
-
-      context "when the operation is a string" do
-        let(:request_builder) { build_request_builder("get_user") }
-        it "should set the SOAP input tag to <get_user>" do
-          soap_input = [nil, :get_user, {}]
-          soap.expects(:input=).with(soap_input)
-
-          request_builder.request
-        end
-      end
-
-      context "when attributes are specified" do
-        it "should add the attributes to the SOAP input" do
-          request_builder.attributes = { :active => true }
-          soap_input = [nil, :getUser, { :active => true }]
-          soap.expects(:input=).with(soap_input)
-
-          request_builder.request
-        end
-      end
-
-      context "when a SOAP action is specified" do
-        it "sets the SOAPAction header" do
-          request_builder.soap_action = :test_action
-          request_builder.request
-
-          http.headers["SOAPAction"].should == %{"test_action"}
-        end
-      end
-
-      context "when the namespace identifier is specified" do
-        before do
-          @namespace_identifier = :v1
-          request_builder.namespace_identifier = @namespace_identifier
-        end
-
-        it "should set the SOAP namespace identifier to the specified identifier" do
-          soap.expects(:namespace_identifier=).with(@namespace_identifier)
-
-          request_builder.request
-        end
-
-        it "should set the SOAP input to include the specified identifier" do
-          soap_input = [@namespace_identifier, :getUser, {}]
-          soap.expects(:input=).with(soap_input)
-
-          request_builder.request
-        end
-
-        it "should set the SOAP namespace to the one matched by the specified identifier" do
-          namespace = "http://v1_0.ws.auth.order.example.com/"
-          soap.expects(:namespace=).with(namespace)
-
-          request_builder.request
-        end
-      end
-
-      it "adds the WSDL document namespaces to the SOAP::XML object" do
-        request_builder.wsdl.type_namespaces.each do |path, uri|
-          soap.expects(:use_namespace).with(path, uri)
-        end
-
-        request_builder.request
-      end
-
-      it "adds the WSDL document types to the SOAP::XML object" do
-        request_builder.request
-
-        request_builder.wsdl.type_definitions do |path, type|
-          soap.types.has_key?(path).should be_true
-          soap.types[path].should == type
-        end
-      end
-    end
-
-    context "with a post-configuration block given" do
-      it "executes the block" do
-        executed = false
-        blk = lambda { executed = true }
-
-        request_builder.request(&blk)
-        executed.should == true
-      end
-
-      it "executes the block post-configuration" do
-        request_builder.namespace_identifier = :conf
-        blk = lambda { |rb| rb.soap.namespace_identifier = :blk }
-
-        conf_sequence = sequence('conf_sequence')
-        soap.expects(:namespace_identifier=).with(:conf).in_sequence(conf_sequence)
-        soap.expects(:namespace_identifier=).with(:blk).in_sequence(conf_sequence)
-
-        request_builder.request(&blk)
-      end
-
-      context "when the block has an argument" do
-        it "yields self to the block" do
-          request_builder = self.request_builder
-          blk = lambda { |rb_given| rb_given.should == request_builder }
-
-          request_builder.request(&blk)
-        end
-      end
-    end
-  end
-end