search_biomodel 1.0.0 → 1.0.1

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/spec/httpi/auth/ssl_spec.rb

@@ -1,128 +0,0 @@
-require "spec_helper"
-require "httpi/auth/ssl"
-
-describe HTTPI::Auth::SSL do
-
-  describe "VERIFY_MODES" do
-    it "contains the supported SSL verify modes" do
-      HTTPI::Auth::SSL::VERIFY_MODES.should == [:none, :peer, :fail_if_no_peer_cert, :client_once]
-    end
-  end
-
-  describe "#present?" do
-    it "defaults to return false" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.should_not be_present
-    end
-
-    it "returns false if only a client key was specified" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.cert_key_file = "spec/fixtures/client_key.pem"
-
-      ssl.should_not be_present
-    end
-
-    it "returns false if only a client key was specified" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.cert_file = "spec/fixtures/client_cert.pem"
-
-      ssl.should_not be_present
-    end
-
-    it "returns true if both client key and cert are present" do
-      ssl.should be_present
-    end
-
-    it "returns true of the verify_mode is :none" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.verify_mode = :none
-      ssl.should be_present
-    end
-  end
-
-  describe "#verify_mode" do
-    it "defaults to return :peer" do
-      ssl.verify_mode.should == :peer
-    end
-
-    it "sets the verify mode to use" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :none
-      ssl.verify_mode.should == :none
-    end
-
-    it "raises an ArgumentError if the given mode is not supported" do
-      expect { ssl.verify_mode = :invalid }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#cert" do
-    it "returns an OpenSSL::X509::Certificate for the given cert_file" do
-      ssl.cert.should be_a(OpenSSL::X509::Certificate)
-    end
-
-    it "returns nil if no cert_file was given" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.cert.should be_nil
-    end
-  end
-
-  describe "#cert_key" do
-    it "returns a OpenSSL::PKey::RSA for the given cert_key" do
-      ssl.cert_key.should be_a(OpenSSL::PKey::RSA)
-    end
-
-    it "returns nil if no cert_key_file was given" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.cert_key.should be_nil
-    end
-  end
-
-  describe "#ca_cert" do
-    it "returns an OpenSSL::X509::Certificate for the given ca_cert_file" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
-      ssl.ca_cert.should be_a(OpenSSL::X509::Certificate)
-    end
-  end
-
-  describe "#openssl_verify_mode" do
-    it "returns the OpenSSL verify mode for :none" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :none
-      ssl.openssl_verify_mode.should == OpenSSL::SSL::VERIFY_NONE
-    end
-
-    it "returns the OpenSSL verify mode for :peer" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :peer
-      ssl.openssl_verify_mode.should == OpenSSL::SSL::VERIFY_PEER
-    end
-
-    it "returns the OpenSSL verify mode for :fail_if_no_peer_cert" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :fail_if_no_peer_cert
-      ssl.openssl_verify_mode.should == OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
-    end
-
-    it "returns the OpenSSL verify mode for :client_once" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :client_once
-      ssl.openssl_verify_mode.should == OpenSSL::SSL::VERIFY_CLIENT_ONCE
-    end
-  end
-
-  def ssl
-    ssl = HTTPI::Auth::SSL.new
-    ssl.cert_key_file = "spec/fixtures/client_key.pem"
-    ssl.cert_file = "spec/fixtures/client_cert.pem"
-    ssl
-  end
-
-end

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/spec/httpi/httpi_spec.rb

@@ -1,284 +0,0 @@
-require "spec_helper"
-require "httpi"
-
-describe HTTPI do
-  let(:client) { HTTPI }
-  let(:httpclient) { HTTPI::Adapter.load(:httpclient)[1] }
-  let(:curb) { HTTPI::Adapter.load(:curb)[1] }
-
-  describe ".get(request)" do
-    it "executes a GET request using the default adapter" do
-      request = HTTPI::Request.new
-      httpclient.any_instance.expects(:get).with(request)
-
-      client.get request
-    end
-  end
-
-  describe ".get(request, adapter)" do
-    it "executes a GET request using the given adapter" do
-      request = HTTPI::Request.new
-      curb.any_instance.expects(:get).with(request)
-
-      client.get request, :curb
-    end
-  end
-
-  describe ".get(url)" do
-    it "executes a GET request using the default adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      httpclient.any_instance.expects(:get).with(instance_of(HTTPI::Request))
-
-      client.get "http://example.com"
-    end
-  end
-
-  describe ".get(url, adapter)" do
-    it "executes a GET request using the given adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      curb.any_instance.expects(:get).with(instance_of(HTTPI::Request))
-
-      client.get "http://example.com", :curb
-    end
-  end
-
-  describe ".post(request)" do
-    it "executes a POST request using the default adapter" do
-      request = HTTPI::Request.new
-      httpclient.any_instance.expects(:post).with(request)
-
-      client.post request
-    end
-  end
-
-  describe ".post(request, adapter)" do
-    it "executes a POST request using the given adapter" do
-      request = HTTPI::Request.new
-      curb.any_instance.expects(:post).with(request)
-
-      client.post request, :curb
-    end
-  end
-
-  describe ".post(url, body)" do
-    it "executes a POST request using the default adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      HTTPI::Request.any_instance.expects(:body=).with("<some>xml</some>")
-      httpclient.any_instance.expects(:post).with(instance_of(HTTPI::Request))
-
-      client.post "http://example.com", "<some>xml</some>"
-    end
-  end
-
-  describe ".post(url, body, adapter)" do
-    it "executes a POST request using the given adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      HTTPI::Request.any_instance.expects(:body=).with("<some>xml</some>")
-      curb.any_instance.expects(:post).with(instance_of(HTTPI::Request))
-
-      client.post "http://example.com", "<some>xml</some>", :curb
-    end
-  end
-
-  describe ".head(request)" do
-    it "executes a HEAD request using the default adapter" do
-      request = HTTPI::Request.new
-      httpclient.any_instance.expects(:head).with(request)
-
-      client.head request
-    end
-  end
-
-  describe ".head(request, adapter)" do
-    it "executes a HEAD request using the given adapter" do
-      request = HTTPI::Request.new
-      curb.any_instance.expects(:head).with(request)
-
-      client.head request, :curb
-    end
-  end
-
-  describe ".head(url)" do
-    it "executes a HEAD request using the default adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      httpclient.any_instance.expects(:head).with(instance_of(HTTPI::Request))
-
-      client.head "http://example.com"
-    end
-  end
-
-  describe ".head(url, adapter)" do
-    it "executes a HEAD request using the given adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      curb.any_instance.expects(:head).with(instance_of(HTTPI::Request))
-
-      client.head "http://example.com", :curb
-    end
-  end
-
-  describe ".put(request)" do
-    it "executes a PUT request using the default adapter" do
-      request = HTTPI::Request.new
-      httpclient.any_instance.expects(:put).with(request)
-
-      client.put request
-    end
-  end
-
-  describe ".put(request, adapter)" do
-    it "executes a PUT request using the given adapter" do
-      request = HTTPI::Request.new
-      curb.any_instance.expects(:put).with(request)
-
-      client.put request, :curb
-    end
-  end
-
-  describe ".put(url, body)" do
-    it "executes a PUT request using the default adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      HTTPI::Request.any_instance.expects(:body=).with("<some>xml</some>")
-      httpclient.any_instance.expects(:put).with(instance_of(HTTPI::Request))
-
-      client.put "http://example.com", "<some>xml</some>"
-    end
-  end
-
-  describe ".put(url, body, adapter)" do
-    it "executes a PUT request using the given adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      HTTPI::Request.any_instance.expects(:body=).with("<some>xml</some>")
-      curb.any_instance.expects(:put).with(instance_of(HTTPI::Request))
-
-      client.put "http://example.com", "<some>xml</some>", :curb
-    end
-  end
-
-  describe ".delete(request)" do
-    it "executes a DELETE request using the default adapter" do
-      request = HTTPI::Request.new
-      httpclient.any_instance.expects(:delete).with(request)
-
-      client.delete request
-    end
-  end
-
-  describe ".delete(request, adapter)" do
-    it "executes a DELETE request using the given adapter" do
-      request = HTTPI::Request.new
-      curb.any_instance.expects(:delete).with(request)
-
-      client.delete request, :curb
-    end
-  end
-
-  describe ".delete(url)" do
-    it "executes a DELETE request using the default adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      httpclient.any_instance.expects(:delete).with(instance_of(HTTPI::Request))
-
-      client.delete "http://example.com"
-    end
-  end
-
-  describe ".delete(url, adapter)" do
-    it "executes a DELETE request using the given adapter" do
-      HTTPI::Request.any_instance.expects(:url=).with("http://example.com")
-      curb.any_instance.expects(:delete).with(instance_of(HTTPI::Request))
-
-      client.delete "http://example.com", :curb
-    end
-  end
-
-  describe ".request" do
-    it "raises an ArgumentError in case of an invalid request method" do
-      expect { client.request :invalid, HTTPI::Request.new }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe ".adapter=" do
-    it "sets the default adapter to use" do
-      HTTPI::Adapter.expects(:use=).with(:net_http)
-      HTTPI.adapter = :net_http
-    end
-  end
-
-  HTTPI::REQUEST_METHODS.each do |method|
-    describe ".request(#{method}, request, adapter)" do
-      it "delegates to the .#{method} method" do
-        HTTPI.expects(method)
-        client.request method, HTTPI::Request.new
-      end
-    end
-
-    describe ".#{method}" do
-      let(:request) { HTTPI::Request.new :url => "http://example.com" }
-
-      it "raises an ArgumentError in case of an invalid adapter" do
-        expect { client.request method, request, :invalid }.to raise_error(ArgumentError)
-      end
-
-      it "raises an ArgumentError in case of an invalid request" do
-        expect { client.request method, "invalid" }.to raise_error(ArgumentError)
-      end
-
-      HTTPI::Adapter::ADAPTERS.each do |adapter, opts|
-        client_class = {
-          :httpclient => lambda { HTTPClient },
-          :curb       => lambda { Curl::Easy },
-          :net_http   => lambda { Net::HTTP }
-        }
-
-        context "using #{adapter}" do
-          before { opts[:class].any_instance.expects(method) }
-
-          it "logs that we're executing a request" do
-            HTTPI.expects(:log).with(:debug, "HTTPI executes HTTP #{method.to_s.upcase} using the #{adapter} adapter")
-            client.request method, request, adapter
-          end
-
-          it "yields the HTTP client instance used for the request" do
-            block = lambda { |http| http.be_a(client_class[adapter].call) }
-            client.request(method, request, adapter, &block)
-          end
-        end
-      end
-    end
-  end
-
-  context "(with reset)" do
-    before { HTTPI.reset_config! }
-
-    after do
-      HTTPI.reset_config!
-      HTTPI.log = false  # disable for specs
-    end
-
-    describe ".log" do
-      it "defaults to true" do
-        HTTPI.log?.should be_true
-      end
-    end
-
-    describe ".logger" do
-      it "defaults to Logger writing to STDOUT" do
-        HTTPI.logger.should be_a(Logger)
-      end
-    end
-
-    describe ".log_level" do
-      it "defaults to :warn" do
-        HTTPI.log_level.should == :warn
-      end
-    end
-
-    describe ".log" do
-      it "logs the given messages" do
-        HTTPI.log_level = :debug
-        HTTPI.logger.expects(:debug).with("Log this")
-        HTTPI.log "Log", "this"
-      end
-    end
-  end
-
-end

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/spec/httpi/request_spec.rb

@@ -1,135 +0,0 @@
-require "spec_helper"
-require "httpi/request"
-
-describe HTTPI::Request do
-  let(:request) { HTTPI::Request.new }
-
-  describe ".new" do
-    it "accepts a url" do
-      request = HTTPI::Request.new "http://example.com"
-      request.url.should == URI("http://example.com")
-    end
-
-    it "accepts a Hash of accessors to set" do
-      request = HTTPI::Request.new :url => "http://example.com", :open_timeout => 30
-      request.url.should == URI("http://example.com")
-      request.open_timeout.should == 30
-    end
-  end
-
-  describe "#url" do
-    it "lets you specify the URL to access as a String" do
-      request.url = "http://example.com"
-      request.url.should == URI("http://example.com")
-    end
-
-    it "also accepts a URI object" do
-      request.url = URI("http://example.com")
-      request.url.should == URI("http://example.com")
-    end
-
-    it "raises an ArgumentError in case of an invalid url" do
-      expect { request.url = "invalid" }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#proxy" do
-    it "lets you specify the proxy URL to use as a String" do
-      request.proxy = "http://proxy.example.com"
-      request.proxy.should == URI("http://proxy.example.com")
-    end
-
-    it "also accepts a URI object" do
-      request.proxy = URI("http://proxy.example.com")
-      request.proxy.should == URI("http://proxy.example.com")
-    end
-
-    it "raises an ArgumentError in case of an invalid url" do
-      expect { request.proxy = "invalid" }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#ssl" do
-    it "returns false if no request url was specified" do
-      request.should_not be_ssl
-    end
-
-    it "returns false if the request url does not start with https" do
-      request.url = "http://example.com"
-      request.should_not be_ssl
-    end
-
-    it "returns true if the request url starts with https" do
-      request.url = "https://example.com"
-      request.should be_ssl
-    end
-
-    context "with an explicit value" do
-      it "returns the value" do
-        request.ssl = true
-        request.should be_ssl
-      end
-    end
-  end
-
-  describe "#headers" do
-    it "lets you specify a Hash of HTTP request headers" do
-      request.headers = { "Accept-Encoding" => "gzip" }
-      request.headers.should == { "Accept-Encoding" => "gzip" }
-    end
-
-    it "defaults to return an empty Hash" do
-      request.headers.should == {}
-    end
-  end
-
-  describe "#gzip" do
-    it "adds the proper 'Accept-Encoding' header" do
-      request.gzip
-      request.headers["Accept-Encoding"].should == "gzip,deflate"
-    end
-  end
-
-  describe "#body" do
-    it "lets you specify the HTTP request body" do
-      request.body = "<some>xml</some>"
-      request.body.should == "<some>xml</some>"
-    end
-  end
-
-  describe "#open_timeout" do
-    it "lets you specify the open timeout" do
-      request.open_timeout = 30
-      request.open_timeout.should == 30
-    end
-  end
-
-  describe "#read_timeout" do
-    it "lets you specify the read timeout" do
-      request.read_timeout = 45
-      request.read_timeout.should == 45
-    end
-  end
-
-  describe "#auth" do
-    it "returns the authentication object" do
-      request.auth.should be_an(HTTPI::Auth::Config)
-    end
-
-    it "memoizes the authentication object" do
-      request.auth.should equal(request.auth)
-    end
-  end
-
-  describe "#auth?" do
-    it "returns true when auth credentials are specified" do
-      request.auth.basic "username", "password"
-      request.auth?.should be_true
-    end
-
-    it "returns false otherwise" do
-      request.auth?.should be_false
-    end
-  end
-
-end

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/spec/httpi/response_spec.rb

@@ -1,125 +0,0 @@
-require "spec_helper"
-require "httpi/response"
-
-describe HTTPI::Response do
-
-  context "normal" do
-    let(:response) { HTTPI::Response.new 200, {}, Fixture.xml }
-
-    describe "#error?" do
-      it "returns false" do
-        response.should_not be_an_error
-      end
-    end
-
-    describe "#headers" do
-      it "returns the HTTP response headers" do
-        response.headers.should == {}
-      end
-    end
-
-    describe "#code" do
-      it "returns the HTTP response code" do
-        response.code.should == 200
-      end
-
-      it "always returns an Integer" do
-        response = HTTPI::Response.new "200", {}, ""
-        response.code.should == 200
-      end
-    end
-
-    describe "#multipart" do
-      it "returns false" do
-        response.should_not be_multipart
-      end
-    end
-  end
-
-  context "empty" do
-    let(:response) { HTTPI::Response.new 204, {}, nil }
-
-    describe "#body" do
-      it "returns an empty String" do
-        response.body.should == ""
-      end
-    end
-  end
-
-  context "multipart" do
-    let(:response) { HTTPI::Response.new 200, { "Content-Type" => "multipart/related" }, "multipart" }
-
-    describe "#multipart" do
-      it "returns true" do
-        response.should be_multipart
-      end
-    end
-  end
-
-  context "error" do
-    let(:response) { HTTPI::Response.new 404, {}, "" }
-
-    describe "#error?" do
-      it "returns true" do
-        response.should be_an_error
-      end
-    end
-  end
-
-  context "gzipped" do
-    let(:response) { HTTPI::Response.new 200, { "Content-Encoding" => "gzip" }, Fixture.gzip }
-
-    describe "#headers" do
-      it "returns the HTTP response headers" do
-        response.headers.should == { "Content-Encoding" => "gzip" }
-      end
-    end
-
-    describe "#body" do
-      it "returns the (gzip decoded) HTTP response body" do
-        response.body.should == Fixture.xml
-      end
-
-      it "bubbles Zlib errors" do
-        arbitrary_error = Class.new(ArgumentError)
-        Zlib::GzipReader.expects(:new).raises(arbitrary_error)
-        expect { response.body }.to raise_error(arbitrary_error)
-      end
-    end
-
-    describe "#raw_body" do
-      it "returns the raw HTML response body" do
-        response.raw_body.should == Fixture.gzip
-      end
-    end
-  end
-
-  context "DIME" do
-    let(:response) { HTTPI::Response.new 200, { "Content-Type" => "application/dime" }, Fixture.dime }
-
-    describe "#headers" do
-      it "returns the HTTP response headers" do
-        response.headers.should == { "Content-Type" => "application/dime" }
-      end
-    end
-
-    describe "#body" do
-      it "returns the (dime decoded) HTTP response body" do
-        response.body.should == Fixture.xml_dime
-      end
-    end
-
-    describe "#raw_body" do
-      it "returns the raw HTML response body" do
-        response.raw_body.should == Fixture.dime
-      end
-    end
-
-    describe "#attachments" do
-      it "returns proper attachment when given a dime response" do
-        response.attachments.first.data == File.read(File.expand_path("../../fixtures/attachment.gif", __FILE__))
-      end
-    end
-  end
-
-end