simple-client 0.0.2

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/util/version_checker.rb

@@ -0,0 +1,73 @@
+# This code was created based on https://github.com/myronmarston/vcr/blob/master/lib/vcr/util/version_checker.rb
+# Thanks to @myronmarston
+
+module WebMock
+  class VersionChecker
+    def initialize(library_name, library_version, min_patch_level, max_minor_version = nil)
+      @library_name, @library_version = library_name, library_version
+      @min_patch_level, @max_minor_version = min_patch_level, max_minor_version
+
+      @major,     @minor,     @patch     = parse_version(library_version)
+      @min_major, @min_minor, @min_patch = parse_version(min_patch_level)
+      @max_major, @max_minor             = parse_version(max_minor_version) if max_minor_version
+
+      @comparison_result = compare_version
+    end
+
+    def check_version!
+      warn_about_too_low if too_low?
+      warn_about_too_high if too_high?
+    end
+
+  private
+
+    def too_low?
+      @comparison_result == :too_low
+    end
+
+    def too_high?
+      @comparison_result == :too_high
+    end
+
+    def warn_about_too_low
+      warn_in_red "You are using #{@library_name} #{@library_version}. " +
+                  "WebMock supports version #{version_requirement}."
+    end
+
+    def warn_about_too_high
+      warn_in_red "You are using #{@library_name} #{@library_version}. " +
+                  "WebMock is known to work with #{@library_name} #{version_requirement}. " +
+                  "It may not work with this version."
+    end
+
+    def warn_in_red(text)
+      Kernel.warn colorize(text, "\e[31m")
+    end
+
+    def compare_version
+      case
+        when @major < @min_major then :too_low
+        when @max_major && @major > @max_major then :too_high
+        when @major > @min_major then :ok
+        when @minor < @min_minor then :too_low
+        when @max_minor && @minor > @max_minor then :too_high
+        when @minor > @min_minor then :ok
+        when @patch < @min_patch then :too_low
+      end
+    end
+
+    def version_requirement
+      req = ">= #{@min_patch_level}"
+      req += ", < #{@max_major}.#{@max_minor + 1}" if @max_minor
+      req
+    end
+
+    def parse_version(version)
+      version.split('.').map { |v| v.to_i }
+    end
+
+    def colorize(text, color_code)
+      "#{color_code}#{text}\e[0m"
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/version.rb

@@ -0,0 +1,3 @@
+module WebMock
+  VERSION = '1.8.8' unless defined?(::WebMock::VERSION)
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/webmock.rb

@@ -0,0 +1,124 @@
+module WebMock
+
+  def self.included(clazz)
+    WebMock::Deprecation.warning("include WebMock is deprecated. Please include WebMock::API instead")
+    if clazz.instance_methods.map(&:to_s).include?('request')
+      warn "WebMock#request was not included in #{clazz} to avoid name collision"
+    else
+      clazz.class_eval do
+        def request(method, uri)
+          WebMock::Deprecation.warning("WebMock#request is deprecated. Please use WebMock::API#a_request method instead")
+          WebMock.a_request(method, uri)
+        end
+      end
+    end
+  end
+
+  include WebMock::API
+  extend WebMock::API
+
+  class << self
+    alias :request :a_request
+  end
+
+  def self.version
+    VERSION
+  end
+
+  def self.disable!(options = {})
+    except = [options[:except]].flatten.compact
+    HttpLibAdapterRegistry.instance.each_adapter do |name, adapter|
+      adapter.enable!
+      adapter.disable! unless except.include?(name)
+    end
+  end
+
+  def self.enable!(options = {})
+    except = [options[:except]].flatten.compact
+    HttpLibAdapterRegistry.instance.each_adapter do |name, adapter|
+      adapter.disable!
+      adapter.enable! unless except.include?(name)
+    end
+  end
+
+  def self.allow_net_connect!(options = {})
+    Config.instance.allow_net_connect = true
+    Config.instance.net_http_connect_on_start = options[:net_http_connect_on_start]
+  end
+
+  def self.disable_net_connect!(options = {})
+    Config.instance.allow_net_connect = false
+    Config.instance.allow_localhost = options[:allow_localhost]
+    Config.instance.allow = options[:allow]
+    Config.instance.net_http_connect_on_start = options[:net_http_connect_on_start]
+  end
+
+  def self.net_connect_allowed?(uri = nil)
+    if uri.is_a?(String)
+      uri = WebMock::Util::URI.normalize_uri(uri)
+    end
+
+    Config.instance.allow_net_connect ||
+    (
+    Config.instance.allow_localhost && WebMock::Util::URI.is_uri_localhost?(uri)) ||
+    Config.instance.allow && (
+      (Config.instance.allow.kind_of?(Regexp) && uri.to_s =~ Config.instance.allow) ||
+      (
+        Config.instance.allow.respond_to?(:include?) &&
+        (
+          Config.instance.allow.include?(uri.host) ||
+          Config.instance.allow.include?("#{uri.host}:#{uri.port}")
+        )
+      )
+    )
+  end
+
+  def self.reset!
+    WebMock::RequestRegistry.instance.reset!
+    WebMock::StubRegistry.instance.reset!
+  end
+
+  def self.reset_webmock
+    WebMock::Deprecation.warning("WebMock.reset_webmock is deprecated. Please use WebMock.reset! method instead")
+    reset!
+  end
+
+  def self.reset_callbacks
+    WebMock::CallbackRegistry.reset
+  end
+
+  def self.after_request(options={}, &block)
+    WebMock::CallbackRegistry.add_callback(options, block)
+  end
+
+  def self.registered_request?(request_signature)
+    WebMock::StubRegistry.instance.registered_request?(request_signature)
+  end
+
+  def self.print_executed_requests
+    puts WebMock::RequestExecutionVerifier.executed_requests_message
+  end
+
+  def self.globally_stub_request(&block)
+    WebMock::StubRegistry.instance.register_global_stub(&block)
+  end
+
+  %w(
+    allow_net_connect!
+    disable_net_connect!
+    net_connect_allowed?
+    reset_webmock
+    reset_callbacks
+    after_request
+    registered_request?
+  ).each do |method|
+    self.class_eval(%Q(
+                      def #{method}(*args, &block)
+                        WebMock::Deprecation.warning("WebMock##{method} instance method is deprecated. Please use WebMock.#{method} class method instead")
+                        WebMock.#{method}(*args, &block)
+                          end
+    ))
+  end
+
+  self.enable!
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock.rb

@@ -0,0 +1,49 @@
+require 'singleton'
+
+require 'addressable/uri'
+require 'crack'
+
+require 'webmock/deprecation'
+require 'webmock/version'
+
+require 'webmock/errors'
+
+require 'webmock/util/uri'
+require 'webmock/util/headers'
+require 'webmock/util/hash_counter'
+require 'webmock/util/hash_keys_stringifier'
+require 'webmock/util/json'
+require 'webmock/util/version_checker'
+
+require 'webmock/matchers/hash_including_matcher'
+
+require 'webmock/request_pattern'
+require 'webmock/request_signature'
+require 'webmock/responses_sequence'
+require 'webmock/request_stub'
+require 'webmock/response'
+require 'webmock/rack_response'
+
+require 'webmock/stub_request_snippet'
+
+require 'webmock/assertion_failure'
+require 'webmock/request_execution_verifier'
+require 'webmock/config'
+require 'webmock/callback_registry'
+require 'webmock/request_registry'
+require 'webmock/stub_registry'
+require 'webmock/api'
+
+require 'webmock/http_lib_adapters/http_lib_adapter_registry'
+require 'webmock/http_lib_adapters/http_lib_adapter'
+require 'webmock/http_lib_adapters/net_http'
+require 'webmock/http_lib_adapters/httpclient_adapter'
+require 'webmock/http_lib_adapters/patron_adapter'
+require 'webmock/http_lib_adapters/curb_adapter'
+require 'webmock/http_lib_adapters/em_http_request_adapter'
+require 'webmock/http_lib_adapters/typhoeus_hydra_adapter'
+require 'webmock/http_lib_adapters/excon_adapter'
+
+require 'webmock/webmock'
+
+

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/minitest/test_helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require File.expand_path(File.dirname(__FILE__) + '/../test/http_request')
+
+gem "minitest"
+require 'minitest/autorun'
+require 'webmock/minitest'
+
+class MiniTest::Unit::TestCase
+  def assert_raise(*exp, &block)
+    assert_raises(*exp, &block)
+  end
+
+  def assert_raise_with_message(e, message, &block)
+     e = assert_raises(e, &block)
+     if message.is_a?(Regexp)
+       assert_match(message, e.message)
+     else
+       assert_equal(message, e.message)
+     end
+   end
+
+   def assert_fail(message, &block)
+     assert_raise_with_message(MiniTest::Assertion, message, &block)
+   end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/minitest/test_webmock.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../test/shared_test')
+
+class MiniTestWebMock < MiniTest::Unit::TestCase
+  include SharedTest
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/minitest/webmock_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+  describe "Webmock" do
+    include HttpRequestTestHelper
+
+    before do
+      @stub_http = stub_http_request(:any, "http://www.example.com")
+      @stub_https = stub_http_request(:any, "https://www.example.com")
+    end
+
+    it "should raise error on non stubbed request" do
+      lambda { http_request(:get, "http://www.example.net/") }.must_raise(WebMock::NetConnectNotAllowedError)
+    end
+
+    it "should verify that expected request occured" do
+      http_request(:get, "http://www.example.com/")
+      assert_requested(:get, "http://www.example.com", :times => 1)
+      assert_requested(:get, "http://www.example.com")
+    end
+
+    it "should verify that expected http stub occured" do
+      http_request(:get, "http://www.example.com/")
+      assert_requested(@stub_http, :times => 1)
+      assert_requested(@stub_http)
+    end
+
+    it "should verify that expected https stub occured" do
+      http_request(:get, "https://www.example.com/")
+      http_request(:get, "https://www.example.com/")
+      assert_requested(@stub_https, :times => 2)
+    end
+
+    it  "should verify that expect request didn't occur" do
+     expected_message = "The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times"
+     expected_message << "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
+     assert_fail(expected_message) do
+       assert_requested(:get, "http://www.example.com")
+     end
+    end
+
+    it  "should verify that expect stub didn't occur" do
+     expected_message = "The request ANY http://www.example.com/ was expected to execute 1 time but it executed 0 times"
+     expected_message << "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
+     assert_fail(expected_message) do
+       assert_requested(@stub_http)
+     end
+    end
+
+  end
+

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/curb/curb_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+
+unless RUBY_PLATFORM =~ /java/
+  require 'acceptance/curb/curb_spec_helper'
+
+  shared_examples_for "Curb" do
+    include CurbSpecHelper
+
+    include_examples "with WebMock"
+
+    describe "when doing PUTs" do
+      it "should stub them" do
+        stub_request(:put, "www.example.com").with(:body => "01234")
+        http_request(:put, "http://www.example.com", :body => "01234").
+          status.should == "200"
+      end
+    end
+  end
+
+  describe "Curb features" do
+    before(:each) do
+      WebMock.disable_net_connect!
+      WebMock.reset!
+    end
+
+    describe "callbacks" do
+      before(:each) do
+        @curl = Curl::Easy.new
+        @curl.url = "http://example.com"
+      end
+
+      it "should call on_success with 2xx response" do
+        body = "on_success fired"
+        stub_request(:any, "example.com").to_return(:body => body)
+
+        test = nil
+        @curl.on_success do |c|
+          test = c.body_str
+        end
+        @curl.http_get
+        test.should == body
+      end
+
+      it "should call on_failure with 4xx response" do
+        response_code = 403
+        stub_request(:any, "example.com").
+          to_return(:status => [response_code, "None shall pass"])
+
+        test = nil
+        @curl.on_failure do |c, code|
+          test = code
+        end
+        @curl.http_get
+        test.should == response_code
+      end
+
+      it "should call on_failure with 5xx response" do
+        response_code = 599
+        stub_request(:any, "example.com").
+          to_return(:status => [response_code, "Server On Fire"])
+
+        test = nil
+        @curl.on_failure do |c, code|
+          test = code
+        end
+        @curl.http_get
+        test.should == response_code
+      end
+
+      it "should call on_body when response body is read" do
+        body = "on_body fired"
+        stub_request(:any, "example.com").
+          to_return(:body => body)
+
+        test = nil
+        @curl.on_body do |data|
+          test = data
+        end
+        @curl.http_get
+        test.should == body
+      end
+
+      it "should call on_header when response headers are read" do
+        stub_request(:any, "example.com").
+          to_return(:headers => {:one => 1})
+
+        test = nil
+        @curl.on_header do |data|
+          test = data
+        end
+        @curl.http_get
+        test.should match(/One: 1/)
+      end
+
+      it "should call on_complete when request is complete" do
+        body = "on_complete fired"
+        stub_request(:any, "example.com").to_return(:body => body)
+
+        test = nil
+        @curl.on_complete do |curl|
+          test = curl.body_str
+        end
+        @curl.http_get
+        test.should == body
+      end
+
+      it "should call on_progress when portion of response body is read" do
+        stub_request(:any, "example.com").to_return(:body => "01234")
+
+        test = nil
+        @curl.on_progress do |*args|
+          args.length.should == 4
+          args.each {|arg| arg.is_a?(Float).should == true }
+          test = true
+        end
+        @curl.http_get
+        test.should == true
+      end
+
+      it "should call callbacks in correct order on successful request" do
+        stub_request(:any, "example.com")
+        order = []
+        @curl.on_success {|*args| order << :on_success }
+        @curl.on_failure {|*args| order << :on_failure }
+        @curl.on_header {|*args| order << :on_header }
+        @curl.on_body {|*args| order << :on_body }
+        @curl.on_complete {|*args| order << :on_complete }
+        @curl.on_progress {|*args| order << :on_progress }
+        @curl.http_get
+
+        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_success]
+      end
+
+      it "should call callbacks in correct order on failed request" do
+        stub_request(:any, "example.com").to_return(:status => [500, ""])
+        order = []
+        @curl.on_success {|*args| order << :on_success }
+        @curl.on_failure {|*args| order << :on_failure }
+        @curl.on_header {|*args| order << :on_header }
+        @curl.on_body {|*args| order << :on_body }
+        @curl.on_complete {|*args| order << :on_complete }
+        @curl.on_progress {|*args| order << :on_progress }
+        @curl.http_get
+
+        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_failure]
+      end
+    end
+
+    describe '#last_effective_url' do
+      before(:each) do
+        @curl = Curl::Easy.new
+        @curl.url = "http://example.com"
+      end
+
+      context 'when not following redirects' do
+        before { @curl.follow_location = false }
+
+        it 'should be the same as #url even with a location header' do
+          stub_request(:any, 'example.com').
+            to_return(:body    => "abc",
+                      :status  => 302,
+                      :headers => { 'Location' => 'http://www.example.com' })
+
+          @curl.http_get
+          @curl.last_effective_url.should == 'http://example.com'
+        end
+      end
+
+      context 'when following redirects' do
+        before { @curl.follow_location = true }
+
+        it 'should be the same as #url when no location header is present' do
+          stub_request(:any, "example.com")
+          @curl.http_get
+          @curl.last_effective_url.should == 'http://example.com'
+        end
+
+        it 'should be the value of the location header when present' do
+          stub_request(:any, 'example.com').
+            to_return(:headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com')
+
+          @curl.http_get
+          @curl.last_effective_url.should == 'http://www.example.com'
+        end
+
+        it 'should work with more than one redirect' do
+          stub_request(:any, 'example.com').
+            to_return(:headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com').
+            to_return(:headers => { 'Location' => 'http://blog.example.com' })
+          stub_request(:any, 'blog.example.com')
+
+          @curl.http_get
+          @curl.last_effective_url.should == 'http://blog.example.com'
+        end
+
+        it 'should maintain the original url' do
+          stub_request(:any, 'example.com').
+            to_return(:headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com')
+
+          @curl.http_get
+          @curl.url.should == 'http://example.com'
+        end
+
+        it 'should have the redirected-to attrs (body, response code)' do
+          stub_request(:any, 'example.com').
+            to_return(:body => 'request A',
+                      :status => 302,
+                      :headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com').to_return(:body => 'request B')
+
+          @curl.http_get
+          @curl.body_str.should == 'request B'
+          @curl.response_code.should == 200
+        end
+
+        it 'should follow more than one redirect' do
+          stub_request(:any, 'example.com').
+            to_return(:headers => { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com').
+            to_return(:headers => { 'Location' => 'http://blog.example.com' })
+          stub_request(:any, 'blog.example.com').to_return(:body => 'blog post')
+
+          @curl.http_get
+          @curl.url.should == 'http://example.com'
+          @curl.body_str.should == 'blog post'
+        end
+      end
+    end
+
+    describe "#content_type" do
+      before(:each) do
+        @curl = Curl::Easy.new
+        @curl.url = "http://example.com"
+      end
+
+      context "when response includes Content-Type header" do
+        it "returns correct content_type" do
+          content_type = "application/json"
+
+          stub_request(:any, 'example.com').
+            to_return(:body     => "abc",
+                      :status   => 200,
+                      :headers  => { 'Content-Type' => content_type })
+
+          @curl.http_get
+          @curl.content_type.should == content_type
+        end
+      end
+
+      context "when response does not include Content-Type header" do
+        it "returns nil for content_type" do
+          content_type = "application/json"
+
+          stub_request(:any, 'example.com').
+            to_return(:body     => "abc",
+                      :status   => 200 )
+
+          @curl.http_get
+          @curl.content_type.should be_nil
+        end
+      end
+    end
+  end
+
+  describe "Webmock with Curb" do
+    describe "using #http for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::DynamicHttp
+
+      it "should work with uppercase arguments" do
+        stub_request(:get, "www.example.com").to_return(:body => "abc")
+
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.http(:GET)
+        c.body_str.should == "abc"
+      end
+    end
+
+    describe "using #http_* methods for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::NamedHttp
+
+      it "should work with blank arguments for post" do
+        stub_request(:post, "www.example.com").with(:body => "01234")
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.post_body = "01234"
+        c.http_post
+        c.response_code.should == 200
+      end
+
+      it "should work with several body arguments for post using the class method" do
+        stub_request(:post, "www.example.com").with(:user => {:first_name=>'Bartosz', :last_name=>'Blimke'})
+        c = Curl::Easy.http_post "http://www.example.com", 'user[first_name]=Bartosz', 'user[last_name]=Blimke'
+        c.response_code.should == 200
+      end
+
+      it "should work with blank arguments for put" do
+        stub_request(:put, "www.example.com").with(:body => "01234")
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.put_data = "01234"
+        c.http_put
+        c.response_code.should == 200
+      end
+
+      it "should work with multiple arguments for post" do
+        data = { :name => "john", :address => "111 example ave" }
+
+        stub_request(:post, "www.example.com").with(:body => data)
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.http_post Curl::PostField.content('name', data[:name]),  Curl::PostField.content('address', data[:address])
+
+        c.response_code.should == 200
+      end
+
+    end
+
+    describe "using #perform for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::Perform
+    end
+
+    describe "using .http_* methods for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::ClassNamedHttp
+    end
+
+    describe "using .perform for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::ClassPerform
+    end
+  end
+end