johnreitano-savon 0.7.2.1 → 0.7.7.1

data/spec/http_stubs.rb

@@ -21,3 +21,6 @@ FakeWeb.register_uri :get, EndpointHelper.wsdl_endpoint(:no_namespace), :body =>
 
 # WSDL request returning a WSDL document with namespaced SOAP actions.
 FakeWeb.register_uri :get, EndpointHelper.wsdl_endpoint(:namespaced_actions), :body => WSDLFixture.namespaced_actions
+
+# WSDL request returning a WSDL document with geotrust SOAP actions.
+FakeWeb.register_uri :get, EndpointHelper.wsdl_endpoint(:geotrust), :body => WSDLFixture.geotrust

data/spec/savon/client_spec.rb

@@ -37,7 +37,7 @@ describe Savon::Client do
 
   it "should disable the Savon::WSDL when passed a method with an exclamation mark" do
     @client.wsdl.enabled?.should be_true
-    [:respond_to?, :operations, :namespace_uri, :soap_endpoint].each do |method|
+    [:operations, :namespace_uri, :soap_endpoint].each do |method|
       Savon::WSDL.any_instance.expects(method).never
     end
 
@@ -70,8 +70,12 @@ describe Savon::Client do
     end
   end
 
+  it "should have a call method that forwards to method_missing for SOAP actions named after existing methods" do
+    @client.call(:authenticate) { |soap| soap.should be_a(Savon::SOAP) }
+  end
+
   it "should raise a NoMethodError when the method does not match an available SOAP action or method" do
     lambda { @client.some_undefined_method }.should raise_error(NoMethodError)
   end
 
-end
+end

data/spec/savon/core_ext/array_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Array do
+
+  describe "to_soap_xml" do
+    describe "should return SOAP request compatible XML" do
+      it "for an Array of Hashes" do
+        hash, result = [{ :name => "Eve" }], "<findUser><name>Eve</name></findUser>"
+        hash.to_soap_xml("findUser").should == result
+      end
+
+      it "for an Array of Strings and other Objects" do
+        hash, result = [:id, :name], "<someValues>id</someValues><someValues>name</someValues>"
+        hash.to_soap_xml("someValues").should == result
+      end
+    end
+  end
+
+end

data/spec/savon/core_ext/datetime_spec.rb

@@ -5,7 +5,7 @@ describe DateTime do
   describe "to_soap_value" do
     it "returns an xs:dateTime compliant String" do
       DateTime.new(2012, 03, 22, 16, 22, 33).to_soap_value.
-        should == "2012-03-22T16:22:33"
+        should == "2012-03-22T16:22:33Z"
     end
   end
 

data/spec/savon/core_ext/hash_spec.rb

@@ -3,135 +3,175 @@ require "spec_helper"
 describe Hash do
 
   describe "find_soap_body" do
-    it "returns the content from the 'soap:Body' element" do
-      { "soap:Envelope" => { "soap:Body" => "content" } }.find_soap_body.should == "content"
+    it "should return the content from the 'soap:Body' element" do
+      soap_body = { "soap:Envelope" => { "soap:Body" => "content" } }
+      soap_body.find_soap_body.should == "content"
     end
 
-    it "returns an empty Hash in case the 'soap:Body' element could not be found" do
-      { "some_hash" => "content" }.find_soap_body.should == {}
+    it "should return an empty Hash in case the 'soap:Body' element could not be found" do
+      soap_body = { "some_hash" => "content" }
+      soap_body.find_soap_body.should == {}
     end
   end
 
   describe "to_soap_xml" do
-    describe "returns SOAP request compatible XML" do
+    describe "should return SOAP request compatible XML" do
       it "for a simple Hash" do
-        { :some => "user" }.to_soap_xml.should == "<some>user</some>"
+        hash, result = { :some => "user" }, "<some>user</some>"
+        hash.to_soap_xml.should == result
       end
 
       it "for a nested Hash" do
-        { :some => { :new => "user" } }.to_soap_xml.
-          should == "<some><new>user</new></some>"
+        hash, result = { :some => { :new => "user" } }, "<some><new>user</new></some>"
+        hash.to_soap_xml.should == result
       end
 
       it "for a Hash with multiple keys" do
-        soap_xml = { :all => "users", :before => "whatever" }.to_soap_xml
-
-        soap_xml.should include("<all>users</all>")
-        soap_xml.should include("<before>whatever</before>")
+        hash = { :all => "users", :before => "whatever" }
+        hash.to_soap_xml.should include("<all>users</all>", "<before>whatever</before>")
       end
 
       it "for a Hash containing an Array" do
-        { :some => ["user", "gorilla"] }.to_soap_xml.
-          should == "<some>user</some><some>gorilla</some>"
+        hash, result = { :some => ["user", "gorilla"] }, "<some>user</some><some>gorilla</some>"
+        hash.to_soap_xml.should == result
       end
 
       it "for a Hash containing an Array of Hashes" do
-        { :some => [{ :new => "user" }, { :old => "gorilla" }] }.to_soap_xml.
-          should == "<some><new>user</new></some><some><old>gorilla</old></some>"
+        hash = { :some => [{ :new => "user" }, { :old => "gorilla" }] }
+        result = "<some><new>user</new></some><some><old>gorilla</old></some>"
+
+        hash.to_soap_xml.should == result
       end
     end
 
-    it "converts Hash key Symbols to lowerCamelCase" do
-      { :find_or_create => "user" }.to_soap_xml.
-        should == "<findOrCreate>user</findOrCreate>"
+    it "should convert Hash key Symbols to lowerCamelCase" do
+      hash, result = { :find_or_create => "user" }, "<findOrCreate>user</findOrCreate>"
+      hash.to_soap_xml.should == result
     end
 
-    it "does not convert Hash key Strings" do
-      { "find_or_create" => "user" }.to_soap_xml.
-        should == "<find_or_create>user</find_or_create>"
+    it "should not convert Hash key Strings" do
+      hash, result = { "find_or_create" => "user" }, "<find_or_create>user</find_or_create>"
+      hash.to_soap_xml.should == result
     end
 
-    it "converts DateTime objects to xs:dateTime compliant Strings" do
-      { :before => DateTime.new(2012, 03, 22, 16, 22, 33) }.to_soap_xml.
-        should == "<before>" << "2012-03-22T16:22:33" << "</before>"
+    it "should convert DateTime objects to xs:dateTime compliant Strings" do
+      hash = { :before => DateTime.new(2012, 03, 22, 16, 22, 33) }
+      result = "<before>2012-03-22T16:22:33Z</before>"
+
+      hash.to_soap_xml.should == result
     end
 
-    it "converts Objects responding to to_datetime to xs:dateTime compliant Strings" do
+    it "should convert Objects responding to to_datetime to xs:dateTime compliant Strings" do
       singleton = Object.new
       def singleton.to_datetime
         DateTime.new(2012, 03, 22, 16, 22, 33)
       end
 
-      { :before => singleton }.to_soap_xml.
-        should == "<before>" << "2012-03-22T16:22:33" << "</before>"
+      hash, result = { :before => singleton }, "<before>2012-03-22T16:22:33Z</before>"
+      hash.to_soap_xml.should == result
     end
 
-    it "calls to_s on Strings even if they respond to to_datetime" do
+    it "should call to_s on Strings even if they respond to to_datetime" do
       object = "gorilla"
-      object.expects(:to_s).returns object
       object.expects(:to_datetime).never
 
-      { :name => object }.to_soap_xml.should == "<name>gorilla</name>"
+      hash, result = { :name => object }, "<name>gorilla</name>"
+      hash.to_soap_xml.should == result
     end
 
-    it "call to_s on any other Object" do
+    it "should call to_s on any other Object" do
       [666, true, false, nil].each do |object|
         { :some => object }.to_soap_xml.should == "<some>#{object}</some>"
       end
     end
 
-    it "preserves the order of Hash keys and values specified through :@inorder" do
-      { :find_user => { :name => "Lucy", :id => 666, :@inorder => [:id, :name] } }.to_soap_xml.
-        should == "<findUser><id>666</id><name>Lucy</name></findUser>"
+    it "should preserve the order of Hash keys and values specified through :order!" do
+      hash = { :find_user => { :name => "Lucy", :id => 666, :order! => [:id, :name] } }
+      result = "<findUser><id>666</id><name>Lucy</name></findUser>"
+      hash.to_soap_xml.should == result
+
+      hash = { :find_user => { :mname => "in the", :lname => "Sky", :fname => "Lucy", :order! => [:fname, :mname, :lname] } }
+      result = "<findUser><fname>Lucy</fname><mname>in the</mname><lname>Sky</lname></findUser>"
+      hash.to_soap_xml.should == result
+    end
+
+    it "should raise an error if the :order! Array does not match the Hash keys" do
+      hash = { :name => "Lucy", :id => 666, :order! => [:name] }
+      lambda { hash.to_soap_xml }.should raise_error(ArgumentError)
 
-      { :find_user => { :by_name => { :mname => "in the", :lname => "Sky", :fname => "Lucy",
-        :@inorder => [:fname, :mname, :lname] } } }.to_soap_xml. should ==
-        "<findUser><byName><fname>Lucy</fname><mname>in the</mname><lname>Sky</lname></byName></findUser>"
+      hash = { :by_name => { :name => "Lucy", :lname => "Sky", :order! => [:mname, :name] } }
+      lambda { hash.to_soap_xml }.should raise_error(ArgumentError)
     end
 
-    it "raises an error if the :@inorder Array does not match the Hash keys" do
-      lambda { { :name => "Lucy", :id => 666, :@inorder => [:name] }.to_soap_xml }.
-        should raise_error(RuntimeError)
+    it "should add attributes to Hash keys specified through :attributes!" do
+      hash = { :find_user => { :person => "Lucy", :attributes! => { :person => { :id => 666 } } } }
+      result = '<findUser><person id="666">Lucy</person></findUser>'
+      hash.to_soap_xml.should == result
+
+      hash = { :find_user => { :person => "Lucy", :attributes! => { :person => { :id => 666, :city => "Hamburg" } } } }
+      soap_xml = hash.to_soap_xml
+      soap_xml.should include('id="666"', 'city="Hamburg"')
+    end
 
-      lambda { { :by_name => { :name => "Lucy", :lname => "Sky", :@inorder => [:mname, :name] } }.to_soap_xml }.
-        should raise_error(RuntimeError)
+    it "should add attributes to duplicate Hash keys specified through :attributes!" do
+      hash = { :find_user => { :person => ["Lucy", "Anna"], :attributes! => { :person => { :id => [1, 3] } } } }
+      result = '<findUser><person id="1">Lucy</person><person id="3">Anna</person></findUser>'
+      hash.to_soap_xml.should == result
+      
+      hash = { :find_user => { :person => ["Lucy", "Anna"], :attributes! => { :person => { :active => "true" } } } }
+      result = '<findUser><person active="true">Lucy</person><person active="true">Anna</person></findUser>'
+      hash.to_soap_xml.should == result
     end
   end
 
   describe "map_soap_response" do
-    it "converts Hash key Strings to snake_case Symbols" do
-      { "userResponse" => { "accountStatus" => "active" } }.map_soap_response.
-        should == { :user_response => { :account_status => "active" } }
+    it "should convert Hash key Strings to snake_case Symbols" do
+      soap_response = { "userResponse" => { "accountStatus" => "active" } }
+      result = { :user_response => { :account_status => "active" } }
+
+      soap_response.map_soap_response.should == result
     end
 
-    it "strips namespaces from Hash keys" do
-      { "ns:userResponse" => { "ns2:id" => "666" } }.map_soap_response.
-        should == { :user_response => { :id => "666" } }
+    it "should strip namespaces from Hash keys" do
+      soap_response = { "ns:userResponse" => { "ns2:id" => "666" } }
+      result = { :user_response => { :id => "666" } }
+
+      soap_response.map_soap_response.should == result
     end
 
-    it "converts Hash keys and values in Arrays" do
-      { "response" => [{ "name" => "dude" }, { "name" => "gorilla" }] }.map_soap_response.
-        should == { :response=> [{ :name => "dude" }, { :name => "gorilla" }] }
+    it "should convert Hash keys and values in Arrays" do
+      soap_response = { "response" => [{ "name" => "dude" }, { "name" => "gorilla" }] }
+      result = { :response=> [{ :name => "dude" }, { :name => "gorilla" }] }
+
+      soap_response.map_soap_response.should == result
     end
 
-    it "converts xsi:nil values to nil Objects" do
-      { "userResponse" => { "xsi:nil" => "true" } }.map_soap_response.
-        should == { :user_response => nil }
+    it "should convert xsi:nil values to nil Objects" do
+      soap_response = { "userResponse" => { "xsi:nil" => "true" } }
+      result = { :user_response => nil }
+
+      soap_response.map_soap_response.should == result
     end
 
-    it "converts Hash values matching the xs:dateTime format into DateTime Objects" do
-      { "response" => { "at" => "2012-03-22T16:22:33" } }.map_soap_response.
-        should == { :response => { :at => DateTime.new(2012, 03, 22, 16, 22, 33) } }
+    it "should convert Hash values matching the xs:dateTime format into DateTime Objects" do
+      soap_response = { "response" => { "at" => "2012-03-22T16:22:33" } }
+      result = { :response => { :at => DateTime.new(2012, 03, 22, 16, 22, 33) } }
+
+      soap_response.map_soap_response.should == result
     end
 
-    it "converts Hash values matching 'true' to TrueClass" do
-      { "response" => { "active" => "false" } }.map_soap_response.
-        should == { :response => { :active => false } }
+    it "should convert Hash values matching 'true' to TrueClass" do
+      soap_response = { "response" => { "active" => "false" } }
+      result = { :response => { :active => false } }
+
+      soap_response.map_soap_response.should == result
     end
 
-    it "converts Hash values matching 'false' to FalseClass" do
-      { "response" => { "active" => "true" } }.map_soap_response.
-        should == { :response => { :active => true } }
+    it "should convert Hash values matching 'false' to FalseClass" do
+      soap_response = { "response" => { "active" => "true" } }
+      result = { :response => { :active => true } }
+
+      soap_response.map_soap_response.should == result
     end
   end
 

data/spec/savon/core_ext/object_spec.rb

@@ -29,7 +29,7 @@ describe Object do
         DateTime.new(2012, 03, 22, 16, 22, 33)
       end
 
-      singleton.to_soap_value.should == "2012-03-22T16:22:33"
+      singleton.to_soap_value.should == "2012-03-22T16:22:33Z"
     end
 
     it "calls to_s unless the Object responds to to_datetime" do

data/spec/savon/core_ext/string_spec.rb

@@ -30,6 +30,21 @@ describe String do
     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"
@@ -60,8 +75,12 @@ describe String do
   end
 
   describe "to_soap_value" do
-    it "calls to_s, bypassing Rails to_datetime extension for Strings" do
-      "string".to_soap_value.should == "string".to_s
+    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;"
+      "'apos'".to_soap_value.should == "&apos;apos&apos;"
     end
   end
 

data/spec/savon/core_ext/uri_spec.rb

@@ -10,6 +10,10 @@ describe URI::HTTP do
     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

@@ -4,10 +4,8 @@ describe Savon::Request do
   before { @request = Savon::Request.new EndpointHelper.wsdl_endpoint }
 
   it "contains the ContentType for each supported SOAP version" do
-    Savon::SOAPVersions.each do |soap_version|
-      Savon::Request::ContentType[soap_version].should be_a(String)
-      Savon::Request::ContentType[soap_version].should_not be_empty
-    end
+    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
@@ -24,8 +22,8 @@ describe Savon::Request do
   end
 
   it "has both getter and setter for the logger to use (global setting)" do
-    Savon::Request.logger = nil
-    Savon::Request.logger.should be_nil
+    Savon::Request.logger = {}
+    Savon::Request.logger.should be_a(Hash)
     Savon::Request.logger = Logger.new STDOUT
   end
 
@@ -78,12 +76,18 @@ describe Savon::Request do
   end
 
   it "executes a SOAP request and returns the Net::HTTP response" do
-    soap = Savon::SOAP.new
-    soap.endpoint = URI EndpointHelper.wsdl_endpoint
+    operation = WSDLFixture.authentication(:operations)[:authenticate]
+    action, input = operation[:action], operation[:input]
+    soap = Savon::SOAP.new action, input, EndpointHelper.soap_endpoint
     soap_response = @request.soap soap
 
     soap_response.should be_a(Net::HTTPResponse)
     soap_response.body.should == ResponseFixture.authentication
   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/soap_spec.rb

@@ -2,170 +2,200 @@ require "spec_helper"
 
 describe Savon::SOAP do
   before do
-    @soap = Savon::SOAP.new
-    @soap.action = WSDLFixture.authentication(:operations)[:authenticate][:action]
+    @operation = WSDLFixture.authentication(:operations)[:authenticate]
+    @action, @input = @operation[:action], @operation[:input]
+    @soap = Savon::SOAP.new @action, @input, EndpointHelper.soap_endpoint
   end
 
-  it "contains the SOAP namespace for each supported SOAP version" do
-    Savon::SOAPVersions.each do |soap_version|
-      Savon::SOAP::SOAPNamespace[soap_version].should be_a(String)
-      Savon::SOAP::SOAPNamespace[soap_version].should_not be_empty
+  it "should contain the SOAP namespace for each supported SOAP version" do
+    Savon::SOAP::Versions.each do |soap_version|
+      Savon::SOAP::Namespace[soap_version].should be_a(String)
+      Savon::SOAP::Namespace[soap_version].should_not be_empty
     end
   end
 
-  it "contains the Content-Types for each supported SOAP version" do
-    Savon::SOAPVersions.each do |soap_version|
+  it "should contain the Content-Types for each supported SOAP version" do
+    Savon::SOAP::Versions.each do |soap_version|
       Savon::SOAP::ContentType[soap_version].should be_a(String)
       Savon::SOAP::ContentType[soap_version].should_not be_empty
     end
   end
 
-  it "defaults to SOAP 1.1" do
-    Savon::SOAP.version.should == 1
+  it "should contain an Array of supported SOAP versions" do
+    Savon::SOAP::Versions.should be_an(Array)
+    Savon::SOAP::Versions.should_not be_empty
   end
 
-  it "has both getter and setter for the SOAP version to use (global setting)" do
-    [2, 1].each do |soap_version|
-      Savon::SOAP.version = soap_version
-      Savon::SOAP.version.should == soap_version
-    end
-  end
+  it "should contain the xs:dateTime format" do
+    Savon::SOAP::DateTimeFormat.should be_a(String)
+    Savon::SOAP::DateTimeFormat.should_not be_empty
 
-  it "has a setter for the Savon::WSSE" do
-    @soap.wsse = Savon::WSSE.new
+    DateTime.new(2012, 03, 22, 16, 22, 33).strftime(Savon::SOAP::DateTimeFormat).
+      should == "2012-03-22T16:22:33Z"
   end
 
-  it "is has both getter and setter for the SOAP action" do
-    @soap.action.should == WSDLFixture.authentication(:operations)[:authenticate][:action]
-
-    @soap.action = "someAction"
-    @soap.action.should == "someAction"
+  it "should contain a Regexp matching the xs:dateTime format" do
+    Savon::SOAP::DateTimeRegexp.should be_a(Regexp)
+    (Savon::SOAP::DateTimeRegexp === "2012-03-22T16:22:33").should be_true
   end
 
-  it "has a setter for the SOAP input" do
-    @soap.input = "FindUserRequest"
+  it "should default to SOAP 1.1" do
+    Savon::SOAP.version.should == 1
   end
 
-  it "has both getter and setter for global SOAP headers" do
-    header = { "some" => "header" }
-    Savon::SOAP.header = header
-    Savon::SOAP.header.should == header
+  describe "xml returned via to_xml" do
+    before do
+      @xml_declaration = '<?xml version="1.0" encoding="UTF-8"?>'
+      @namespace = { "xmlns:ns" => "http://example.com" }
+      @namespace_string = 'xmlns:ns="http://example.com"'
+      @namespaces = { "xmlns:ns" => "http://ns.example.com", "xmlns:ns2" => "http://ns2.example.com" }
+      
+      # reset to defaults
+      Savon::SOAP.version = 1
+      Savon::SOAP.header = {}
+      Savon::SOAP.namespaces = {}
+    end
 
-    Savon::SOAP.header = {}
-  end
+    it "should contain an xml declaration" do
+      @soap.to_xml.should include(@xml_declaration)
+    end
 
-  it "has both getter and setter for the SOAP header" do
-    @soap.header.should be_a(Hash)
-    @soap.header.should be_empty
+    # namespaces
 
-    @soap.header = { "specialAuthKey" => "secret" }
-    @soap.header.should == { "specialAuthKey" => "secret" }
-  end
+    it "should contain the namespace for SOAP 1.1" do
+      @soap.to_xml.should include('xmlns:env="' + Savon::SOAP::Namespace[1] + '"')
+    end
 
-  it "has a getter for the SOAP body, expecting a Hash or an XML String" do
-    @soap.body = { :id => 666 }
-    @soap.body = "<id>666</id>"
-  end
+    it "should contain the namespace for SOAP 1.2 when defined globally" do
+      Savon::SOAP.version = 2
+      @soap.to_xml.should include('xmlns:env="' + Savon::SOAP::Namespace[2] + '"')
+    end
 
-  it "has a setter for specifying a Hash of namespaces" do
-    namespaces = { "xmlns:env" => "http://example.com" }
-    @soap.namespaces = namespaces
-    @soap.namespaces.should == namespaces
-  end
+    it "should contain the namespace for SOAP 1.2 when defined per request" do
+      @soap.version = 2
+      @soap.to_xml.should include('xmlns:env="' + Savon::SOAP::Namespace[2] + '"')
+    end
 
-  describe "has a getter for namespaces" do
-    it "which defaults to include the SOAP 1.1 namespace" do
-      @soap.namespaces.should == { "xmlns:env" => Savon::SOAP::SOAPNamespace[1] }
+    it "should containg a xmlns:wsdl namespace defined via the :namespace shortcut method" do
+      @soap.namespace = "http://wsdl.example.com"
+      @soap.to_xml.should include('xmlns:wsdl="http://wsdl.example.com"')
     end
 
-    it "which contains the SOAP 1.2 namespace if specified" do
-      @soap.version = 2
-      @soap.namespaces.should == { "xmlns:env" => Savon::SOAP::SOAPNamespace[2] }
+    it "should accept custom namespaces when defined globally" do
+      Savon::SOAP.namespaces = @namespace
+      @soap.to_xml.should include("<env:Envelope " + @namespace_string)
     end
-  end
 
-  it "has both getter and setter for global namespaces" do
-    namespaces = { "some" => "namespace" }
-    Savon::SOAP.namespaces = namespaces
-    Savon::SOAP.namespaces.should == namespaces
+    it "should accept custom namespaces when defined per request" do
+      @soap.namespaces = @namespace
+      @soap.to_xml.should include("<env:Envelope " + @namespace_string)
+    end
 
-    Savon::SOAP.namespaces = {}
-  end
+    it "should merge global and per request namespaces" do
+      Savon::SOAP.namespaces = @namespaces
+      @soap.namespaces = @namespace
+      @soap.to_xml.should include(
+        'xmlns:ns="http://example.com"',
+        'xmlns:ns2="http://ns2.example.com"'
+      )
+    end
 
-  it "has a convenience method for setting the 'xmlns:wsdl' namespace" do
-    @soap.namespaces.should == { "xmlns:env" => "http://schemas.xmlsoap.org/soap/envelope/" }
+    # header
 
-    @soap.namespace = "http://example.com"
-    @soap.namespaces.should include("xmlns:env" => "http://schemas.xmlsoap.org/soap/envelope/")
-    @soap.namespaces.should include("xmlns:wsdl" => "http://example.com")
-  end
+    it "should not contain a header tag unless specified" do
+      @soap.to_xml.should_not include("<env:Header>")
+    end
 
-  it "has both getter and setter for the SOAP endpoint" do
-    @soap.endpoint.should be_nil
+    it "should accept a custom (String) header defined globally" do
+      Savon::SOAP.header = "<key>value</key>"
+      @soap.to_xml.should include("<env:Header><key>value</key></env:Header>")
+    end
 
-    soap_endpoint = URI EndpointHelper.soap_endpoint
-    @soap.endpoint = soap_endpoint
-    @soap.endpoint.should == soap_endpoint
-  end
+    it "should accept a custom (Hash) header defined globally" do
+      Savon::SOAP.header[:key] = "value"
+      @soap.to_xml.should include("<env:Header><key>value</key></env:Header>")
+    end
 
-  it "has a getter for the SOAP version to use which defaults to SOAP 1.1" do
-    @soap.version.should == Savon::SOAP.version
-  end
+    it "should accept a custom (String) header defined per request" do
+      @soap.header = "<key>value</key>"
+      @soap.to_xml.should include("<env:Header><key>value</key></env:Header>")
+    end
 
-  it "has a setter for specifying the SOAP version to use" do
-    @soap.version = 2
-    @soap.version.should == 2
-  end
+    it "should accept a custom (Hash) header defined per request" do
+      @soap.header[:key] = "value"
+      @soap.to_xml.should include("<env:Header><key>value</key></env:Header>")
+    end
 
-  describe "to_xml" do
-    after { Savon::SOAP.version = 1 }
+    it "should merge global and per request headers defined as Strings" do
+      Savon::SOAP.header = "<key2>other value</key2>"
+      @soap.header = "<key>value</key>"
+      @soap.to_xml.should include(
+        "<env:Header><key2>other value</key2><key>value</key></env:Header>"
+      )
+    end
 
-    it "returns the XML for a SOAP request" do
-      @soap.namespaces["xmlns:wsdl"] = "http://v1_0.ws.auth.order.example.com/"
-      @soap.body = { :id => 666 }
+    it "should merge global and per request headers defined as Hashes" do
+      Savon::SOAP.header = { :key => "value", :key2 => "global value" }
+      @soap.header[:key2] = "request value"
+      @soap.to_xml.should include(
+        "<env:Header><key>value</key><key2>request value</key2></env:Header>"
+      )
+    end
 
-      @soap.to_xml.should include('xmlns:wsdl="http://v1_0.ws.auth.order.example.com/"')
-      @soap.to_xml.should include('xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"')
-      @soap.to_xml.should include('<wsdl:authenticate><id>666</id></wsdl:authenticate>')
+    it "should use the :header method from a given WSSE object to include a WSSE header" do
+      wsse = "some compliant object"
+      wsse.stubs(:header).returns("<wsse>authentication</wsse>")
+      
+      @soap.wsse = wsse
+      @soap.to_xml.should include("<env:Header><wsse>authentication</wsse></env:Header>")
     end
 
-    it "caches the XML, returning the same Object every time" do
-      @soap.to_xml.object_id.should == @soap.to_xml.object_id
+    # input tag
+
+    it "should contain a :wsdl namespaced input tag matching the :input property on instantiation" do
+      @soap = Savon::SOAP.new "someAction", "someInput", EndpointHelper.soap_endpoint
+      @soap.to_xml.should include('<wsdl:someInput>')
     end
 
-    it "uses the SOAP namespace for the specified SOAP version" do
-      @soap.version = 2
-      @soap.to_xml.should include(Savon::SOAP::SOAPNamespace[2])
+    it "should fall back to using the :action property whem :input is blank" do
+      @soap = Savon::SOAP.new "someAction", "", EndpointHelper.soap_endpoint
+      @soap.to_xml.should include('<wsdl:someAction>')
     end
 
-    it "uses the SOAP namespace for the default SOAP version otherwise" do
-      Savon::SOAP.version = 2
-      @soap.to_xml.should include(Savon::SOAP::SOAPNamespace[2])
+    it "should containg namespaces defined via an input tag Array containing the tag name and a Hash of namespaces" do
+      input = ["someInput", { "otherNs" => "http://otherns.example.com" }]
+      @soap = Savon::SOAP.new "someAction", input, EndpointHelper.soap_endpoint
+      @soap.to_xml.should include('<wsdl:someInput otherNs="http://otherns.example.com">')
     end
 
-    it "merges global and per request headers defined as Hashes" do
-      Savon::SOAP.header = { "API-KEY" => "secret", "SOME-KEY" => "something" }
-      @soap.header["SOME-KEY"] = "somethingelse"
+    # xml body
+
+    it "should contain the SOAP body defined as a Hash" do
+      @soap.body = { :someTag => "some value" }
+      @soap.to_xml.should include("<someTag>some value</someTag>")
+    end
 
-      @soap.to_xml.should include("<API-KEY>secret</API-KEY>")
-      @soap.to_xml.should include("<SOME-KEY>somethingelse</SOME-KEY>")
+    it "should contain the SOAP body defined as an Object responding to :to_s" do
+      @soap.body = "<someTag>some value</someTag>"
+      @soap.to_xml.should include(@soap.body)
     end
 
-    it "joins global and per request headers defined as Strings" do
-      Savon::SOAP.header = "<API-KEY>secret</API-KEY>"
-      @soap.header = "<SOME-KEY>somethingelse</SOME-KEY>"
+    # xml
 
-      @soap.to_xml.should include("<API-KEY>secret</API-KEY>")
-      @soap.to_xml.should include("<SOME-KEY>somethingelse</SOME-KEY>")
+    it "should be a completely custom XML when specified" do
+      @soap.xml = "custom SOAP body"
+      @soap.to_xml.should == @soap.xml
     end
 
-    it "merges the global and per request namespaces" do
-      Savon::SOAP.namespaces = { "xmlns:wsdl" => "namespace", "xmlns:v1" => "v1namespace" }
-      @soap.namespaces["xmlns:v1"] = "newV1namespace"
+    # safety check
 
-      @soap.to_xml.should include('xmlns:wsdl="namespace"')
-      @soap.to_xml.should include('xmlns:v1="newV1namespace"')
+    it "should be a valid SOAP request" do
+      @soap.to_xml.should include(
+        @xml_declaration +
+        '<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">' <<
+          '<env:Body><wsdl:authenticate></wsdl:authenticate></env:Body>' <<
+        '</env:Envelope>'
+      ) 
     end
   end
-
-end
+end