savon 1.2.0 → 2.0.0

data/spec/savon/soap/request_spec.rb

@@ -1,112 +0,0 @@
-require "spec_helper"
-
-describe Savon::SOAP::Request do
-
-  let(:soap_request)  { Savon::SOAP::Request.new(config, http_request, soap_xml) }
-  let(:http_request)  { HTTPI::Request.new }
-  let(:http_response) { HTTPI::Response.new 200, {}, Fixture.response(:authentication) }
-
-  let(:config) {
-    config = Savon::Config.default
-    config.log = false
-    config
-  }
-
-  def soap_xml(*args)
-    @soap_xml ||= soap_xml!(*args)
-  end
-
-  def soap_xml!(endpoint = nil, input = nil, body = nil)
-    soap = Savon::SOAP::XML.new(config)
-    soap.endpoint = endpoint || Endpoint.soap
-    soap.input    = input    || [nil, :get_user, {}]
-    soap.body     = body     || { :id => 1 }
-    soap
-  end
-
-  it "contains the content type for each supported SOAP version" do
-    content_type = Savon::SOAP::Request::CONTENT_TYPE
-    content_type[1].should == "text/xml;charset=UTF-8"
-    content_type[2].should == "application/soap+xml;charset=UTF-8"
-  end
-
-  describe ".execute" do
-    it "executes a SOAP request and returns the response" do
-      HTTPI.expects(:post).returns(http_response)
-      response = Savon::SOAP::Request.execute config, http_request, soap_xml
-      response.should be_a(Savon::SOAP::Response)
-    end
-  end
-
-  describe ".new" do
-    it "uses the SOAP endpoint for the request" do
-      soap_request.http.url.should == URI(soap_xml.endpoint)
-    end
-
-    it "sets the SOAP body for the request" do
-      soap_request.http.body.should == soap_xml.to_xml
-    end
-
-    it "sets the Content-Type header for SOAP 1.1" do
-      soap_request.http.headers["Content-Type"].should == Savon::SOAP::Request::CONTENT_TYPE[1]
-    end
-
-    it "sets the Content-Type header for SOAP 1.2" do
-      soap_xml.version = 2
-      soap_request.http.headers["Content-Type"].should == Savon::SOAP::Request::CONTENT_TYPE[2]
-    end
-
-    it "sets the Content-Length header" do
-      soap_request.http.headers["Content-Length"].should == soap_xml.to_xml.length.to_s
-    end
-
-    it "sets the Content-Length header for every request" do
-      http = HTTPI::Request.new
-      soap_request = Savon::SOAP::Request.new(config, http, soap_xml)
-      http.headers.should include("Content-Length" => "272")
-
-      soap_xml = soap_xml!(Endpoint.soap, [nil, :create_user, {}], :id => 123)
-      soap_request = Savon::SOAP::Request.new(config, http, soap_xml)
-      http.headers.should include("Content-Length" => "280")
-    end
-  end
-
-  describe "#response" do
-    it "executes an HTTP POST request and returns a Savon::SOAP::Response" do
-      HTTPI.expects(:post).returns(http_response)
-      soap_request.response.should be_a(Savon::SOAP::Response)
-    end
-
-    context "with a :soap_request hook" do
-      it "lets you replace the HTTP request and return your own response" do
-        config.hooks.define(:test, :soap_request) do |_, request|
-          request.should be_a(Savon::SOAP::Request)
-          http_response
-        end
-
-        response = soap_request.response
-        response.http.should equal(http_response)
-      end
-
-      it "works as an around filter for the SOAP request" do
-        HTTPI.expects(:post).returns(http_response)
-        state = []
-
-        config.hooks.define(:test, :soap_request) do |callback, request|
-          state << :before
-          response = callback.call
-          state << response
-          state << :after
-          response
-        end
-
-        response = soap_request.response
-
-        state[0].should == :before
-        state[1].should be_a(HTTPI::Response)
-        state[2].should == :after
-      end
-    end
-  end
-
-end

data/spec/savon/soap/xml_spec.rb

@@ -1,357 +0,0 @@
-require "spec_helper"
-
-describe Savon::SOAP::XML do
-
-  def xml(endpoint = nil, input = nil, body = nil)
-    @xml ||= begin
-      xml = Savon::SOAP::XML.new(config)
-      xml.endpoint = endpoint || Endpoint.soap
-      xml.input    = input    || [nil, :authenticate, {}]
-      xml.body     = body     || { :id => 1 }
-      xml
-    end
-  end
-
-  let(:config) { Savon::Config.default }
-
-  describe "#input" do
-    it "should set the input tag" do
-      xml.input = :test
-      xml.input.should == :test
-    end
-  end
-
-  describe "#endpoint" do
-    it "should set the endpoint to use" do
-      xml.endpoint = "http://test.com"
-      xml.endpoint.should == "http://test.com"
-    end
-  end
-
-  describe "#version" do
-    it "should default to SOAP 1.1" do
-      xml.version.should == 1
-    end
-
-    it "should default to the global default" do
-      config.soap_version = 2
-      xml.version.should == 2
-    end
-
-    it "should set the SOAP version to use" do
-      xml.version = 2
-      xml.version.should == 2
-    end
-
-    it "should raise an ArgumentError in case of an invalid version" do
-      lambda { xml.version = 3 }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "#header" do
-    it "should default to an empty Hash" do
-      xml.header.should == {}
-    end
-
-    it "should set the SOAP header" do
-      xml.header = { "MySecret" => "abc" }
-      xml.header.should == { "MySecret" => "abc" }
-    end
-
-    it "should use the global soap_header if set" do
-      config.stubs(:soap_header).returns({ "MySecret" => "abc" })
-      xml.header.should == { "MySecret" => "abc" }
-    end
-  end
-
-  describe "#env_namespace" do
-    it "should default to :env" do
-      xml.env_namespace.should == :env
-    end
-
-    it "should set the SOAP envelope namespace" do
-      xml.env_namespace = :soapenv
-      xml.env_namespace.should == :soapenv
-    end
-
-    it "should use the global env_namespace if set as the SOAP envelope namespace" do
-      config.stubs(:env_namespace).returns(:soapenv)
-      xml.env_namespace.should == :soapenv
-    end
-  end
-
-  describe "#namespaces" do
-    it "should default to a Hash containing the namespace for SOAP 1.1" do
-      xml.namespaces.should == { "xmlns:env" => "http://schemas.xmlsoap.org/soap/envelope/" }
-    end
-
-    it "should default to a Hash containing the namespace for SOAP 1.2 if that's the current version" do
-      xml.version = 2
-      xml.namespaces.should == { "xmlns:env" => "http://www.w3.org/2003/05/soap-envelope" }
-    end
-
-    it "should set the SOAP header" do
-      xml.namespaces = { "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
-      xml.namespaces.should == { "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
-    end
-  end
-
-  describe "#wsse" do
-    it "should set the Akami::WSSE object" do
-      xml.wsse = Akami.wsse
-      xml.wsse.should be_a(Akami::WSSE)
-    end
-  end
-
-  describe "#body" do
-    it "should set the SOAP body Hash" do
-      xml.body = { :id => 1 }
-      xml.to_xml.should include("<id>1</id>")
-    end
-
-    it "should accepts an XML String" do
-      xml.body = "<id>1</id>"
-      xml.to_xml.should include("<id>1</id>")
-    end
-
-    it "should accept a block" do
-      xml.body do |body|
-        body.user { body.id 1 }
-      end
-
-      xml.to_xml.should include("<authenticate><user><id>1</id></user></authenticate>")
-    end
-  end
-
-  describe "#encoding" do
-    it "defaults to UTF-8" do
-      xml.encoding.should == "UTF-8"
-    end
-  end
-
-  describe "#xml" do
-    it "lets you specify a completely custom XML String" do
-      xml.xml = "<custom>xml</custom>"
-      xml.to_xml.should == "<custom>xml</custom>"
-    end
-
-    it "yields a Builder::XmlMarkup object to a given block" do
-      xml.xml { |xml| xml.using("Builder") }
-      xml.to_xml.should == '<?xml version="1.0" encoding="UTF-8"?><using>Builder</using>'
-    end
-
-    it "accepts options to pass to the Builder::XmlMarkup instruct!" do
-      xml.xml :xml, :aaa => :bbb do |xml|
-        xml.using("Builder")
-      end
-
-      xml.to_xml.should == '<?xml version="1.0" encoding="UTF-8" aaa="bbb"?><using>Builder</using>'
-    end
-
-    it "allows to change the encoding" do
-      xml.xml(:xml, :encoding => "US-ASCII") { |xml| xml.using("Builder") }
-      xml.to_xml.should == '<?xml version="1.0" encoding="US-ASCII"?><using>Builder</using>'
-    end
-  end
-
-  describe "#to_xml" do
-    context "by default" do
-      it "should start with an XML declaration" do
-        xml.to_xml.should match(/^<\?xml version="1.0" encoding="UTF-8"\?>/)
-      end
-
-      it "should use default SOAP envelope namespace" do
-        xml.to_xml.should include("<env:Envelope", "<env:Body")
-      end
-
-      it "should add the xsd namespace" do
-        uri = "http://www.w3.org/2001/XMLSchema"
-        xml.to_xml.should match(/<env:Envelope (.*)xmlns:xsd="#{uri}"(.*)>/)
-      end
-
-      it "should add the xsi namespace" do
-        uri = "http://www.w3.org/2001/XMLSchema-instance"
-        xml.to_xml.should match(/<env:Envelope (.*)xmlns:xsi="#{uri}"(.*)>/)
-      end
-
-      it "should have a SOAP envelope tag with a SOAP 1.1 namespace" do
-        uri = "http://schemas.xmlsoap.org/soap/envelope/"
-        xml.to_xml.should match(/<env:Envelope (.*)xmlns:env="#{uri}"(.*)>/)
-      end
-
-      it "should have a SOAP body containing the SOAP input tag and body Hash" do
-        xml.to_xml.should include('<env:Body><authenticate><id>1</id></authenticate></env:Body>')
-      end
-
-      it "should accept a SOAP body as an XML String" do
-        xml.body = "<someId>1</someId>"
-        xml.to_xml.should include('<env:Body><authenticate><someId>1</someId></authenticate></env:Body>')
-      end
-
-      it "should not contain a SOAP header" do
-        xml.to_xml.should_not include('<env:Header')
-      end
-    end
-
-    context "with a custom encoding" do
-      after do
-        xml.encoding = nil
-      end
-
-      it "should change the default encoding" do
-        xml.encoding = "US-ASCII"
-        xml.to_xml.should match(/^<\?xml version="1.0" encoding="US-ASCII"\?>/)
-      end
-    end
-
-    context "with a SOAP header" do
-      context "as a Hash" do
-        it "should contain the given header" do
-          xml.header = {
-            :token => "secret",
-            :attributes! => { :token => { :xmlns => "http://example.com" } }
-          }
-
-          xml.to_xml.should include('<env:Header><token xmlns="http://example.com">secret</token></env:Header>')
-        end
-      end
-
-      context "as a String" do
-        it "should contain the given header" do
-          xml.header = %{<token xmlns="http://example.com">secret</token>}
-
-          xml.to_xml.should include('<env:Header><token xmlns="http://example.com">secret</token></env:Header>')
-        end
-      end
-    end
-
-    context "with the global SOAP version set to 1.2" do
-      it "should contain the namespace for SOAP 1.2" do
-        config.soap_version = 2
-
-        uri = "http://www.w3.org/2003/05/soap-envelope"
-        xml.to_xml.should match(/<env:Envelope (.*)xmlns:env="#{uri}"(.*)>/)
-      end
-    end
-
-    context "with a global and request SOAP version" do
-      it "should contain the namespace for the request SOAP version" do
-        config.soap_version = 2
-        xml.version = 1
-
-        uri = "http://schemas.xmlsoap.org/soap/envelope/"
-        xml.to_xml.should match(/<env:Envelope (.*)xmlns:env="#{uri}"(.*)>/)
-      end
-    end
-
-    context "with the SOAP envelope namespace set to an empty String" do
-      it "should not add a namespace to SOAP envelope tags" do
-        xml.env_namespace = ""
-        xml.to_xml.should include("<Envelope", "<Body")
-      end
-    end
-
-    context "using the #namespace and #namespace_identifier" do
-      it "should contain the specified namespace" do
-        xml.namespace_identifier = :wsdl
-        xml.namespace = "http://example.com"
-        xml.to_xml.should include('xmlns:wsdl="http://example.com"')
-      end
-    end
-
-    context "with :element_form_default set to :qualified and a :namespace" do
-      it "should namespace the default elements" do
-        xml = xml(Endpoint.soap, [nil, :authenticate, {}], :user => { :id => 1, ":noNamespace" => true })
-        xml.element_form_default = :qualified
-        xml.namespace_identifier = :wsdl
-
-        xml.to_xml.should include("<wsdl:user>", "<wsdl:id>1</wsdl:id>", "<noNamespace>true</noNamespace>")
-      end
-    end
-
-    context "with :element_form_default set to :unqualified and a :namespace" do
-      it "should namespace the default elements" do
-        xml = xml(Endpoint.soap, [nil, :authenticate, {}], :user => { :id => 1, ":noNamespace" => true })
-        xml.element_form_default = :unqualified
-        xml.namespace_identifier = :wsdl
-
-        xml.to_xml.should include("<user>", "<id>1</id>", "<noNamespace>true</noNamespace>")
-      end
-    end
-
-    context "with WSSE authentication" do
-      it "should containg a SOAP header with WSSE authentication details" do
-        xml.wsse = Akami.wsse
-        xml.wsse.credentials "username", "password"
-
-        xml.to_xml.should include("<env:Header><wsse:Security")
-        xml.to_xml.should include("<wsse:Username>username</wsse:Username>")
-        xml.to_xml.should include("password</wsse:Password>")
-      end
-    end
-
-    context "with a simple input tag (Symbol)" do
-      it "should just add the input tag" do
-        xml.input = [nil, :simple, {}]
-        xml.to_xml.should include('<simple><id>1</id></simple>')
-      end
-    end
-
-    context "with a simple input tag (Array)" do
-      it "should just add the input tag" do
-        xml.input = [nil, :simple, {}]
-        xml.to_xml.should include('<simple><id>1</id></simple>')
-      end
-    end
-
-    context "with an input tag and a namespace Hash (Array)" do
-      it "should contain the input tag with namespaces" do
-        xml.input = [nil, :getUser, { "active" => true }]
-        xml.to_xml.should include('<getUser active="true"><id>1</id></getUser>')
-      end
-    end
-
-    context "with a prefixed input tag (Array)" do
-      it "should contain a prefixed input tag" do
-        xml.input = [:wsdl, :getUser, {}]
-        xml.to_xml.should include('<wsdl:getUser><id>1</id></wsdl:getUser>')
-      end
-    end
-
-    context "with a prefixed input tag and a namespace Hash (Array)" do
-      it "should contain a prefixed input tag with namespaces" do
-        xml.input = [:wsdl, :getUser, { :only_active => false }]
-        xml.to_xml.should include('<wsdl:getUser only_active="false"><id>1</id></wsdl:getUser>')
-      end
-    end
-  end
-
-  describe "#add_namespaces_to_body" do
-    before :each do
-      xml.used_namespaces.merge!({
-        ["authenticate", "id"] =>"ns0",
-        ["authenticate", "name"] =>"ns1",
-        ["authenticate", "name", "firstName"] =>"ns2"
-      })
-    end
-
-    it "adds namespaces" do
-      body = {:id => 1, :name => {:first_name => 'Bob'}}
-      xml.send(:add_namespaces_to_body, body).should == {"ns0:id" => "1", "ns1:name" => {"ns2:firstName" => "Bob"}}
-    end
-
-    it "adds namespaces to order! list" do
-      body = {:id => 1, :name => {:first_name => 'Bob', :order! => [:first_name]}, :order! => [:id, :name]}
-      xml.send(:add_namespaces_to_body, body).should == {
-        "ns0:id" => "1",
-        "ns1:name" => {
-          "ns2:firstName" => "Bob",
-          :order! => ["ns2:firstName"]
-        },
-        :order! => ["ns0:id", "ns1:name"]
-      }
-    end
-  end
-
-end
-