search_biomodel 1.0.0 → 1.0.1

data/search_biomodel/ruby/1.8/gems/savon-0.9.2/spec/fixtures/wsdl/no_namespace.xml

@@ -1,115 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<definitions name="Api" xmlns:typens="urn:ActionWebService" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" targetNamespace="urn:ActionWebService" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns="http://schemas.xmlsoap.org/wsdl/">
-  <types>
-    <xsd:schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:ActionWebService">
-      <xsd:complexType name="MpUser">
-        <xsd:all>
-          <xsd:element name="avatar_thumb_url" type="xsd:string"/>
-          <xsd:element name="speciality" type="xsd:string"/>
-          <xsd:element name="avatar_icon_url" type="xsd:string"/>
-          <xsd:element name="firstname" type="xsd:string"/>
-          <xsd:element name="city" type="xsd:string"/>
-          <xsd:element name="mp_id" type="xsd:int"/>
-          <xsd:element name="lastname" type="xsd:string"/>
-          <xsd:element name="login" type="xsd:string"/>
-        </xsd:all>
-      </xsd:complexType>
-      <xsd:complexType name="MpUserArray">
-        <xsd:complexContent>
-          <xsd:restriction base="soapenc:Array">
-            <xsd:attribute wsdl:arrayType="typens:MpUser[]" ref="soapenc:arrayType"/>
-          </xsd:restriction>
-        </xsd:complexContent>
-      </xsd:complexType>
-      <xsd:complexType name="McContact">
-        <xsd:all>
-          <xsd:element name="last_name" type="xsd:string"/>
-          <xsd:element name="email" type="xsd:string"/>
-          <xsd:element name="mp_id" type="xsd:int"/>
-          <xsd:element name="role" type="xsd:int"/>
-          <xsd:element name="login" type="xsd:string"/>
-          <xsd:element name="first_name" type="xsd:string"/>
-        </xsd:all>
-      </xsd:complexType>
-      <xsd:complexType name="McContactArray">
-        <xsd:complexContent>
-          <xsd:restriction base="soapenc:Array">
-            <xsd:attribute wsdl:arrayType="typens:McContact[]" ref="soapenc:arrayType"/>
-          </xsd:restriction>
-        </xsd:complexContent>
-      </xsd:complexType>
-    </xsd:schema>
-  </types>
-  <message name="GetUserLoginById">
-    <part name="api_key" type="xsd:string"/>
-    <part name="id" type="xsd:int"/>
-  </message>
-  <message name="GetUserLoginByIdResponse">
-    <part name="return" type="xsd:string"/>
-  </message>
-  <message name="GetAllContacts">
-    <part name="api_key" type="xsd:string"/>
-    <part name="login" type="xsd:string"/>
-  </message>
-  <message name="GetAllContactsResponse">
-    <part name="return" type="typens:McContactArray"/>
-  </message>
-  <message name="SearchUser">
-    <part name="api_key" type="xsd:string"/>
-    <part name="phrase" type="xsd:string"/>
-    <part name="page" type="xsd:string"/>
-    <part name="per_page" type="xsd:string"/>
-  </message>
-  <message name="SearchUserResponse">
-    <part name="return" type="typens:MpUserArray"/>
-  </message>
-  <portType name="ApiApiPort">
-    <operation name="GetUserLoginById">
-      <input message="typens:GetUserLoginById"/>
-      <output message="typens:GetUserLoginByIdResponse"/>
-    </operation>
-    <operation name="GetAllContacts">
-      <input message="typens:GetAllContacts"/>
-      <output message="typens:GetAllContactsResponse"/>
-    </operation>
-    <operation name="SearchUser">
-      <input message="typens:SearchUser"/>
-      <output message="typens:SearchUserResponse"/>
-    </operation>
-  </portType>
-  <binding name="ApiApiBinding" type="typens:ApiApiPort">
-    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="rpc"/>
-    <operation name="GetUserLoginById">
-      <soap:operation soapAction="/api/api/GetUserLoginById"/>
-      <input>
-        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="urn:ActionWebService" use="encoded"/>
-      </input>
-      <output>
-        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="urn:ActionWebService" use="encoded"/>
-      </output>
-    </operation>
-    <operation name="GetAllContacts">
-      <soap:operation soapAction="/api/api/GetAllContacts"/>
-      <input>
-        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="urn:ActionWebService" use="encoded"/>
-      </input>
-      <output>
-        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="urn:ActionWebService" use="encoded"/>
-      </output>
-    </operation>
-    <operation name="SearchUser">
-      <soap:operation soapAction="/api/api/SearchUser"/>
-      <input>
-        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="urn:ActionWebService" use="encoded"/>
-      </input>
-      <output>
-        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="urn:ActionWebService" use="encoded"/>
-      </output>
-    </operation>
-  </binding>
-  <service name="ApiService">
-    <port name="ApiApiPort" binding="typens:ApiApiBinding">
-      <soap:address location="http://example.com/api/api"/>
-    </port>
-  </service>
-</definitions>

data/search_biomodel/ruby/1.8/gems/savon-0.9.2/spec/fixtures/wsdl/soap12.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Example of a WSDL with SOAP 1.2 and no SOAP 1.1 endpoint.
-     Don't know whether this is widespread, but we should allow it. -->
-<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-    <service name="Blog">
-        <port name="BlogSoap12">
-            <soap12:address location="http://blogsite.example.com/endpoint12"/>
-        </port>
-    </service>
-</definitions>
-

data/search_biomodel/ruby/1.8/gems/savon-0.9.2/spec/fixtures/wsdl/two_bindings.xml

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Example of a WSDL with two <binding> tags ("sections" in Savon
-     parlance).
-
-     This is stripped down from a real example found in the wild, although
-     having different operations for the SOAP 1.1 and SOAP 1.2 bindings
-     is hypothetical (the real-world example I saw had the same operations
-     in each binding section). -->
-<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-    <types>
-    </types>
-    <portType name="BlogSoap">
-    </portType>
-    <binding name="BlogSoap">
-        <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document"/>
-        <operation name="Post" />
-        <operation name="Post11only" />
-    </binding>
-    <binding name="BlogSoap12">
-        <soap12:binding transport="http://schemas.xmlsoap.org/soap/http" style="document"/>
-        <operation name="Post" />
-        <operation name="Post12only" />
-    </binding>
-</definitions>
-

data/search_biomodel/ruby/1.8/gems/savon-0.9.2/spec/savon/client_spec.rb

@@ -1,354 +0,0 @@
-require "spec_helper"
-
-describe Savon::Client do
-  let(:client) { Savon::Client.new { wsdl.document = Endpoint.wsdl } }
-
-  describe ".new" do
-    context "with a String" do
-      it "should set the WSDL document" do
-        wsdl = "http://example.com/UserService?wsdl"
-        client = Savon::Client.new wsdl
-        client.wsdl.instance_variable_get("@document").should == wsdl
-      end
-    end
-
-    context "with a block expecting one argument" do
-      it "should yield the WSDL object" do
-        Savon::Client.new { |wsdl| wsdl.should be_a(Savon::WSDL::Document) }
-      end
-    end
-
-    context "with a block expecting two arguments" do
-      it "should yield the WSDL and HTTP objects" do
-        Savon::Client.new do |wsdl, http|
-          wsdl.should be_an(Savon::WSDL::Document)
-          http.should be_an(HTTPI::Request)
-        end
-      end
-    end
-
-    context "with a block expecting three arguments" do
-      it "should yield the WSDL, HTTP and WSSE objects" do
-        Savon::Client.new do |wsdl, http, wsse|
-          wsdl.should be_an(Savon::WSDL::Document)
-          http.should be_an(HTTPI::Request)
-          wsse.should be_an(Savon::WSSE)
-        end
-      end
-    end
-
-    context "with a block expecting no arguments" do
-      it "should let you access the WSDL object" do
-        Savon::Client.new { wsdl.should be_a(Savon::WSDL::Document) }
-      end
-
-      it "should let you access the HTTP object" do
-        Savon::Client.new { http.should be_an(HTTPI::Request) }
-      end
-
-      it "should let you access the WSSE object" do
-        Savon::Client.new { wsse.should be_a(Savon::WSSE) }
-      end
-    end
-  end
-
-  describe "#wsdl" do
-    it "should return the Savon::WSDL::Document" do
-      client.wsdl.should be_a(Savon::WSDL::Document)
-    end
-  end
-
-  describe "#http" do
-    it "should return the HTTPI::Request" do
-      client.http.should be_an(HTTPI::Request)
-    end
-  end
-
-  describe "#wsse" do
-    it "should return the Savon::WSSE object" do
-      client.wsse.should be_a(Savon::WSSE)
-    end
-  end
-
-  describe "#request" do
-    before do
-      HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:authentication)))
-      HTTPI.stubs(:post).returns(new_response)
-    end
-
-    context "without any arguments" do
-      it "should raise an ArgumentError" do
-        lambda { client.request }.should raise_error(ArgumentError)
-      end
-    end
-
-    context "with a single argument (Symbol)" do
-      it "should set the input tag to result in <getUser>" do
-        client.request(:get_user) { soap.input.should == [:getUser, {}] }
-      end
-
-      it "should set the target namespace with the default identifier" do
-        namespace = 'xmlns:wsdl="http://v1_0.ws.auth.order.example.com/"'
-        HTTPI::Request.any_instance.expects(:body=).with { |value| value.include? namespace }
-
-        client.request :get_user
-      end
-
-      it "should not set the target namespace if soap.namespace was set to nil" do
-        namespace = "http://v1_0.ws.auth.order.example.com/"
-        HTTPI::Request.any_instance.expects(:body=).with { |value| !value.include?(namespace) }
-
-        client.request(:get_user) { soap.namespace = nil }
-      end
-    end
-
-    context "with a single argument (String)" do
-      it "should set the input tag to result in <get_user>" do
-        client.request("get_user") { soap.input.should == [:get_user, {}] }
-      end
-    end
-
-    context "with a Symbol and a Hash" do
-      it "should set the input tag to result in <getUser active='true'>" do
-        client.request(:get_user, :active => true) { soap.input.should == [:getUser, { :active => true }] }
-      end
-    end
-
-    context "with two Symbols" do
-      it "should set the input tag to result in <wsdl:getUser>" do
-        client.request(:v1, :get_user) { soap.input.should == [:v1, :getUser, {}] }
-      end
-
-      it "should set the target namespace with the given identifier" do
-        namespace = 'xmlns:v1="http://v1_0.ws.auth.order.example.com/"'
-        HTTPI::Request.any_instance.expects(:body=).with { |value| value.include? namespace }
-
-        client.request :v1, :get_user
-      end
-
-      it "should not set the target namespace if soap.namespace was set to nil" do
-        namespace = "http://v1_0.ws.auth.order.example.com/"
-        HTTPI::Request.any_instance.expects(:body=).with { |value| !value.include?(namespace) }
-
-        client.request(:v1, :get_user) { soap.namespace = nil }
-      end
-    end
-
-    context "with two Symbols and a Hash" do
-      it "should set the input tag to result in <wsdl:getUser active='true'>" do
-        client.request(:wsdl, :get_user, :active => true) { soap.input.should == [:wsdl, :getUser, { :active => true }] }
-      end
-    end
-
-    context "with a block expecting one argument" do
-      it "should yield the SOAP object" do
-        client.request(:authenticate) { |soap| soap.should be_a(Savon::SOAP::XML) }
-      end
-    end
-
-    context "with a block expecting two arguments" do
-      it "should yield the SOAP and WSDL objects" do
-        client.request(:authenticate) do |soap, wsdl|
-          soap.should be_a(Savon::SOAP::XML)
-          wsdl.should be_an(Savon::WSDL::Document)
-        end
-      end
-    end
-
-    context "with a block expecting three arguments" do
-      it "should yield the SOAP, WSDL and HTTP objects" do
-        client.request(:authenticate) do |soap, wsdl, http|
-          soap.should be_a(Savon::SOAP::XML)
-          wsdl.should be_an(Savon::WSDL::Document)
-          http.should be_an(HTTPI::Request)
-        end
-      end
-    end
-
-    context "with a block expecting four arguments" do
-      it "should yield the SOAP, WSDL, HTTP and WSSE objects" do
-        client.request(:authenticate) do |soap, wsdl, http, wsse|
-          soap.should be_a(Savon::SOAP::XML)
-          wsdl.should be_a(Savon::WSDL::Document)
-          http.should be_an(HTTPI::Request)
-          wsse.should be_a(Savon::WSSE)
-        end
-      end
-    end
-
-    context "with a block expecting no arguments" do
-      it "should let you access the SOAP object" do
-        client.request(:authenticate) { soap.should be_a(Savon::SOAP::XML) }
-      end
-
-      it "should let you access the HTTP object" do
-        client.request(:authenticate) { http.should be_an(HTTPI::Request) }
-      end
-
-      it "should let you access the WSSE object" do
-        client.request(:authenticate) { wsse.should be_a(Savon::WSSE) }
-      end
-
-      it "should let you access the WSDL object" do
-        client.request(:authenticate) { wsdl.should be_a(Savon::WSDL::Document) }
-      end
-    end
-
-    it "should not set the Cookie header for the next request" do
-      client.http.headers.expects(:[]=).with("Cookie", anything).never
-      client.http.headers.stubs(:[]=).with("SOAPAction", '"authenticate"')
-      client.http.headers.stubs(:[]=).with("Content-Type", "text/xml;charset=UTF-8")
-
-      client.request :authenticate
-    end
-  end
-
-  context "#request with a Set-Cookie response header" do
-    before do
-      HTTPI.stubs(:get).returns(new_response(:body => Fixture.wsdl(:authentication)))
-      HTTPI.stubs(:post).returns(new_response(:headers => { "Set-Cookie" => "some-cookie" }))
-    end
-
-    it "should set the Cookie header for the next request" do
-      client.http.headers.expects(:[]=).with("Cookie", "some-cookie")
-      client.http.headers.stubs(:[]=).with("SOAPAction", '"authenticate"')
-      client.http.headers.stubs(:[]=).with("Content-Type", "text/xml;charset=UTF-8")
-
-      client.request :authenticate
-    end
-  end
-
-  context "with a remote WSDL document" do
-    let(:client) { Savon::Client.new { wsdl.document = Endpoint.wsdl } }
-    before { HTTPI.expects(:get).returns(new_response(:body => Fixture.wsdl(:authentication))) }
-
-    it "should return a list of available SOAP actions" do
-      client.wsdl.soap_actions.should == [:authenticate]
-    end
-
-    it "adds a SOAPAction header containing the SOAP action name" do
-      HTTPI.stubs(:post).returns(new_response)
-
-      client.request :authenticate do
-        http.headers["SOAPAction"].should == %{"authenticate"}
-      end
-    end
-
-    it "should execute SOAP requests and return the response" do
-      HTTPI.expects(:post).returns(new_response)
-      response = client.request(:authenticate)
-
-      response.should be_a(Savon::SOAP::Response)
-      response.to_xml.should == Fixture.response(:authentication)
-    end
-  end
-
-  context "with a local WSDL document" do
-    let(:client) { Savon::Client.new { wsdl.document = "spec/fixtures/wsdl/authentication.xml" } } 
-
-    before { HTTPI.expects(:get).never }
-
-    it "should return a list of available SOAP actions" do
-      client.wsdl.soap_actions.should == [:authenticate]
-    end
-
-    it "adds a SOAPAction header containing the SOAP action name" do
-      HTTPI.stubs(:post).returns(new_response)
-
-      client.request :authenticate do
-        http.headers["SOAPAction"].should == %{"authenticate"}
-      end
-    end
-
-    it "should get #element_form_default from the WSDL" do
-      HTTPI.stubs(:post).returns(new_response)
-      Savon::WSDL::Document.any_instance.expects(:element_form_default).returns(:qualified)
-
-      client.request :authenticate
-    end
-
-    it "should execute SOAP requests and return the response" do
-      HTTPI.expects(:post).returns(new_response)
-      response = client.request(:authenticate)
-
-      response.should be_a(Savon::SOAP::Response)
-      response.to_xml.should == Fixture.response(:authentication)
-    end
-  end
-
-  context "without a WSDL document" do
-    let(:client) do
-      Savon::Client.new do
-        wsdl.endpoint = Endpoint.soap
-        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
-      end
-    end
-
-    before { HTTPI.expects(:get).never }
-
-    it "raise an ArgumentError when trying to access the WSDL" do
-      lambda { client.wsdl.soap_actions }.should raise_error(ArgumentError)
-    end
-
-    it "adds a SOAPAction header containing the SOAP action name" do
-      HTTPI.stubs(:post).returns(new_response)
-
-      client.request :authenticate do
-        http.headers["SOAPAction"].should == %{"authenticate"}
-      end
-    end
-
-    it "should not get #element_form_default from the WSDL" do
-      HTTPI.stubs(:post).returns(new_response)
-      Savon::WSDL::Document.any_instance.expects(:element_form_default).never
-
-      client.request :authenticate
-    end
-
-    it "should execute SOAP requests and return the response" do
-      HTTPI.expects(:post).returns(new_response)
-      response = client.request(:authenticate)
-
-      response.should be_a(Savon::SOAP::Response)
-      response.to_xml.should == Fixture.response(:authentication)
-    end
-  end
-
-  context "when encountering a SOAP fault" do
-    let(:client) do
-      Savon::Client.new do
-        wsdl.endpoint = Endpoint.soap
-        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
-      end
-    end
-
-    before { HTTPI::expects(:post).returns(new_response(:code => 500, :body => Fixture.response(:soap_fault))) }
-
-    it "should raise a Savon::SOAP::Fault" do
-      lambda { client.request :authenticate }.should raise_error(Savon::SOAP::Fault)
-    end
-  end
-
-  context "when encountering an HTTP error" do
-    let(:client) do
-      Savon::Client.new do
-        wsdl.endpoint = Endpoint.soap
-        wsdl.namespace = "http://v1_0.ws.auth.order.example.com/"
-      end
-    end
-
-    before { HTTPI::expects(:post).returns(new_response(:code => 500)) }
-
-    it "should raise a Savon::HTTP::Error" do
-      lambda { client.request :authenticate }.should raise_error(Savon::HTTP::Error)
-    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/search_biomodel/ruby/1.8/gems/savon-0.9.2/spec/savon/core_ext/hash_spec.rb

@@ -1,121 +0,0 @@
-require "spec_helper"
-
-describe Hash do
-
-  describe "#deep_merge!" do
-    it "should recursively merge two Hashes" do
-      hash = { :one => 1, "two" => { "three" => 3 } }
-      other_hash = { :four => 4, "two" => { "three" => "merge", :five => 5 } }
-
-      hash.merge!(other_hash).should == { :one => 1, :four => 4, "two" => { "three" => "merge", :five => 5 } }
-    end
-  end
-
-  describe "#find_soap_header" do
-    it "should return the content from the 'soap:Header' element" do
-      soap_header = { "soap:Envelope" => { "soap:Header" => "content" } }
-      soap_header.find_soap_header.should == "content"
-    end
-
-    it "should return an empty Hash in case the 'soap:Header' element could not be found" do
-      soap_header = { "some_hash" => "content" }
-      soap_header.find_soap_header.should == {}
-    end
-  end
-
-  describe "#find_soap_body" do
-    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 "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 "#map_soap_response" do
-    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 "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
-
-    context "with Savon.strip_namespaces set to false" do
-      around do |example|
-        Savon.strip_namespaces = false
-        example.run
-        Savon.strip_namespaces = true
-      end
-
-      it "should not strip namespaces from Hash keys" do
-        soap_response = { "ns:userResponse" => { "ns2:id" => "666" } }
-        result = { "ns:user_response" => { "ns2:id" => "666" } }
-
-        soap_response.map_soap_response.should == result
-      end
-    end
-
-    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 "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 "should convert Hash values matching the xs:dateTime format into DateTime Objects" do
-      soap_response = { "response" => { "at" => "2012-03-22T16:22:33+00:00" } }
-      result = { :response => { :at => DateTime.new(2012, 03, 22, 16, 22, 33) } }
-
-      soap_response.map_soap_response.should == result
-    end
-
-    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 "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
-
-    it "should convert namespaced entries to array elements" do
-      soap_response = {
-        "history" => {
-          "ns10:case" => { "ns10:name" => "a_name" },
-          "ns11:case" => { "ns11:name" => "another_name" }
-        }
-      }
-
-      result = {
-        :history => {
-          :case => [{ :name => "a_name" }, { :name => "another_name" }]
-        }
-      }
-
-      soap_response.map_soap_response.should == result
-    end
-  end
-
-end

data/search_biomodel/ruby/1.8/gems/savon-0.9.2/spec/savon/core_ext/object_spec.rb

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