search_biomodel 1.0.0 → 1.0.1

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

@@ -1,341 +0,0 @@
-require "spec_helper"
-
-describe Savon::SOAP::XML do
-  let(:xml) { Savon::SOAP::XML.new Endpoint.soap, :authenticate, :id => 1 }
-
-  describe ".to_hash" do
-    it "should return a given SOAP response body as a Hash" do
-      hash = Savon::SOAP::XML.to_hash Fixture.response(:authentication)
-      hash[:authenticate_response][:return].should == {
-        :success => true,
-        :authentication_value => {
-          :token_hash => "AAAJxA;cIedoT;mY10ExZwG6JuKgp2OYKxow==",
-          :token => "a68d1d6379b62ff339a0e0c69ed4d9cf",
-          :client => "radclient"
-        }
-      }
-    end
-
-    it "should return a Hash for a SOAP multiRef response" do
-      hash = Savon::SOAP::XML.to_hash Fixture.response(:multi_ref)
-
-      hash[:list_response].should be_a(Hash)
-      hash[:multi_ref].should be_an(Array)
-    end
-
-    it "should add existing namespaced elements as an array" do
-      hash = Savon::SOAP::XML.to_hash Fixture.response(:list)
-
-      hash[:multi_namespaced_entry_response][:history].should be_a(Hash)
-      hash[:multi_namespaced_entry_response][:history][:case].should be_an(Array)
-    end
-  end
-
-  describe ".parse" do
-    it "should convert the given XML into a Hash" do
-      hash = Savon::SOAP::XML.parse Fixture.response(:list)
-      hash["soapenv:Envelope"]["soapenv:Body"].should be_a(Hash)
-    end
-  end
-
-  describe ".to_array" do
-    let(:response_hash) { Fixture.response_hash :authentication }
-
-    context "when the given path exists" do
-      it "should return an Array containing the path value" do
-        Savon::SOAP::XML.to_array(response_hash, :authenticate_response, :return).should ==
-          [response_hash[:authenticate_response][:return]]
-      end
-    end
-
-    context "when the given path returns nil" do
-      it "should return an empty Array" do
-        Savon::SOAP::XML.to_array(response_hash, :authenticate_response, :undefined).should == []
-      end
-    end
-
-    context "when the given path does not exist at all" do
-      it "should return an empty Array" do
-        Savon::SOAP::XML.to_array(response_hash, :authenticate_response, :some, :wrong, :path).should == []
-      end
-    end
-  end
-
-  describe ".new" do
-    it "should accept an endpoint, an input tag and a SOAP body" do
-      xml = Savon::SOAP::XML.new Endpoint.soap, :authentication, :id => 1
-
-      xml.endpoint.should == Endpoint.soap
-      xml.input.should == :authentication
-      xml.body.should == { :id => 1 }
-    end
-  end
-
-  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
-      Savon.soap_version = 2
-      xml.version.should == 2
-
-      reset_soap_version
-    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
-  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
-      Savon.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 Savon::WSSE object" do
-      xml.wsse = Savon::WSSE.new
-      xml.wsse.should be_a(Savon::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 also accepts an XML String" do
-      xml.body = "<id>1</id>"
-      xml.to_xml.should include("<id>1</id>")
-    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
-  end
-
-  describe "#to_xml" do
-    after { reset_soap_version }
-
-    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 SOAP header" 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 "with the global SOAP version set to 1.2" do
-      it "should contain the namespace for SOAP 1.2" do
-        Savon.soap_version = 2
-
-        uri = "http://www.w3.org/2003/05/soap-envelope"
-        xml.to_xml.should match(/<env:Envelope (.*)xmlns:env="#{uri}"(.*)>/)
-        reset_soap_version
-      end
-    end
-
-    context "with a global and request SOAP version" do
-      it "should contain the namespace for the request SOAP version" do
-        Savon.soap_version = 2
-        xml.version = 1
-
-        uri = "http://schemas.xmlsoap.org/soap/envelope/"
-        xml.to_xml.should match(/<env:Envelope (.*)xmlns:env="#{uri}"(.*)>/)
-        reset_soap_version
-      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
-      let :xml do
-        Savon::SOAP::XML.new Endpoint.soap, :authenticate, :user => { :id => 1, ":noNamespace" => true }
-      end
-
-      it "should namespace the default elements" do
-        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 WSSE authentication" do
-      it "should containg a SOAP header with WSSE authentication details" do
-        xml.wsse = Savon::WSSE.new
-        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 = :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 = :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 = [: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
-
-  def reset_soap_version
-    Savon.soap_version = Savon::SOAP::DefaultVersion
-  end
-
-end
-

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

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe Savon::SOAP do
-
-  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 "should contain a Rage of supported SOAP versions" do
-    Savon::SOAP::Versions.should == (1..2)
-  end
-
-  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
-
-end

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

@@ -1,132 +0,0 @@
-require "spec_helper"
-
-describe Savon::WSDL::Document do
-
-  shared_examples_for "a WSDL document" do
-    it "should be present" do
-      wsdl.should be_present
-    end
-
-    describe "#namespace" do
-      it "should return the namespace URI" do
-        wsdl.namespace.should == "http://v1_0.ws.auth.order.example.com/"
-      end
-    end
-
-    describe "#soap_actions" do
-      it "should return an Array of available SOAP actions" do
-        wsdl.soap_actions.should == [:authenticate]
-      end
-    end
-
-    describe "#soap_action" do
-      it "should return the SOAP action for a given key" do
-        wsdl.soap_action(:authenticate).should == "authenticate"
-      end
-
-      it "should return nil if no SOAP action could be found" do
-        wsdl.soap_action(:unknown).should be_nil
-      end
-    end
-
-    describe "#soap_input" do
-      it "should return the SOAP input tag for a given key" do
-        wsdl.soap_input(:authenticate).should == :authenticate
-      end
-
-      it "should return nil if no SOAP input tag could be found" do
-        wsdl.soap_input(:unknown).should be_nil
-      end
-    end
-
-    describe "#operations" do
-      it "should return a Hash of SOAP operations" do
-        wsdl.operations.should == {
-          :authenticate => {
-            :input => "authenticate", :action => "authenticate"
-          }
-        }
-      end
-    end
-
-    describe "#document" do
-      it "should return the raw WSDL document" do
-        wsdl.document.should == Fixture.wsdl(:authentication)
-      end
-
-      it "should be memoized" do
-        wsdl.document.should equal(wsdl.document)
-      end
-    end
-  end
-
-  context "with a remote document" do
-    let(:wsdl) { Savon::WSDL::Document.new HTTPI::Request.new, Endpoint.wsdl }
-
-    before do
-      response = HTTPI::Response.new 200, {}, Fixture.wsdl(:authentication)
-      HTTPI.stubs(:get).returns(response)
-    end
-
-    it_should_behave_like "a WSDL document"
-
-    describe "#element_form_default" do
-      it "should return :unqualified" do
-        wsdl.element_form_default.should == :unqualified
-      end
-    end
-  end
-
-  context "with a local document" do
-    let(:wsdl) do
-      wsdl = "spec/fixtures/wsdl/authentication.xml"
-      Savon::WSDL::Document.new HTTPI::Request.new, wsdl
-    end
-
-    before { HTTPI.expects(:get).never }
-
-    it_should_behave_like "a WSDL document"
-  end
-
-  context "without a WSDL document" do
-    let(:wsdl) { Savon::WSDL::Document.new HTTPI::Request.new }
-
-    it "should not be present" do
-      wsdl.should_not be_present
-    end
-
-    describe "#soap_action" do
-      it "should return nil" do
-        wsdl.soap_action(:authenticate).should be_nil
-      end
-    end
-
-    describe "#soap_input" do
-      it "should return nil" do
-        wsdl.soap_input(:authenticate).should be_nil
-      end
-    end
-
-    describe "#document" do
-      it "should raise an ArgumentError" do
-        lambda { wsdl.document }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  context "with a WSDL document containing elementFormDefault='qualified'" do
-    let(:wsdl) { Savon::WSDL::Document.new HTTPI::Request.new, Endpoint.wsdl }
-
-    before do
-      response = HTTPI::Response.new 200, {}, Fixture.wsdl(:geotrust)
-      HTTPI.stubs(:get).returns(response)
-    end
-
-    describe "#element_form_default" do
-      it "should return :qualified" do
-        wsdl.element_form_default.should == :qualified
-      end
-    end
-  end
-
-end

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

@@ -1,107 +0,0 @@
-require "spec_helper"
-
-describe Savon::WSDL::Parser do
-
-  context "with namespaced_actions.xml" do
-    let(:parser) { new_parser :namespaced_actions }
-
-    it "should return the target namespace" do
-      parser.namespace.should == "http://api.example.com/api/"
-    end
-
-    it "should return the SOAP endpoint" do
-      parser.endpoint.should == URI("https://api.example.com/api/api.asmx")
-    end
-
-    it "should return the available SOAP operations" do
-      parser.operations.should match_operations(
-        :get_api_key => { :input => "GetApiKey", :action => "http://api.example.com/api/User.GetApiKey" },
-        :delete_client => { :input => "DeleteClient", :action => "http://api.example.com/api/Client.Delete" },
-        :get_clients => { :input => "GetClients", :action => "http://api.example.com/api/User.GetClients" }
-      )
-    end
-
-    it "should return that :element_form_default is set to :qualified" do
-      parser.element_form_default.should == :qualified
-    end
-  end
-
-  context "with no_namespace.xml" do
-    let(:parser) { new_parser :no_namespace }
-
-    it "should return the target namespace" do
-      parser.namespace.should == "urn:ActionWebService"
-    end
-
-    it "should return the SOAP endpoint" do
-      parser.endpoint.should == URI("http://example.com/api/api")
-    end
-
-    it "should return the available SOAP operations" do
-      parser.operations.should match_operations(
-        :search_user => { :input => "SearchUser", :action => "/api/api/SearchUser" },
-        :get_user_login_by_id => { :input => "GetUserLoginById", :action => "/api/api/GetUserLoginById" },
-        :get_all_contacts => { :input => "GetAllContacts", :action => "/api/api/GetAllContacts" }
-      )
-    end
-
-    it "should return that :element_form_default is set to :unqualified" do
-      parser.element_form_default.should == :unqualified
-    end
-  end
-
-  context "with geotrust.xml" do
-    let(:parser) { new_parser :geotrust }
-
-    it "should return the target namespace" do
-      parser.namespace.should == "http://api.geotrust.com/webtrust/query"
-    end
-
-    it "should return the SOAP endpoint" do
-      parser.endpoint.should == URI("https://test-api.geotrust.com/webtrust/query.jws")
-    end
-
-    it "should return the available SOAP operations" do
-      parser.operations.should match_operations(
-        :get_quick_approver_list => { :input => "GetQuickApproverList", :action => "GetQuickApproverList" },
-        :hello => { :input => "hello", :action => "hello" }
-      )
-    end
-
-    it "should return that :element_form_default is set to :qualified" do
-      parser.element_form_default.should == :qualified
-    end
-  end
-
-  context "with two_bindings.xml" do
-    let(:parser) { new_parser :two_bindings }
-
-    it "should merge operations from all binding sections (until we have an example where it makes sense to do otherwise)" do
-      parser.operations.keys.map(&:to_s).sort.should ==
-        %w{post post11only post12only}
-    end
-  end
-
-  context "with soap12.xml" do
-    let(:parser) { new_parser :soap12 }
-
-    it "should return the endpoint" do
-      parser.endpoint.should == URI("http://blogsite.example.com/endpoint12")
-    end
-  end
-
-  RSpec::Matchers.define :match_operations do |expected|
-    match do |actual|
-      actual.should have(expected.keys.size).items
-      actual.keys.should include(*expected.keys)
-      actual.each { |key, value| value.should == expected[key] }
-    end
-  end
-
-  def new_parser(fixture)
-    parser = Savon::WSDL::Parser.new(Nokogiri::XML(Fixture[:wsdl, fixture]))
-    parser.parse
-    parser
-  end
-
-end

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

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-describe Savon::WSDL::Request do
-  let(:http_request) { HTTPI::Request.new :url => Endpoint.wsdl }
-  let(:request) { Savon::WSDL::Request.new http_request }
-
-  describe "#response" do
-    it "execute an HTTP GET request and return the HTTPI::Response" do
-      response = HTTPI::Response.new 200, {}, Fixture.response(:authentication)
-      HTTPI.expects(:get).with(http_request).returns(response)
-      request.response.should == response
-    end
-  end
-
-end