social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/shared_example_groups/request_hooks.rb

@@ -1,59 +0,0 @@
-shared_examples_for "request hooks" do |library_hook_name, request_type|
-  let(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
-
-  def make_request(disabled = false)
-    make_http_request(:get, request_url)
-  end
-
-  def assert_expected_response(response)
-    expect(response.status.code).to eq(200)
-    expect(response.body).to eq('FOO!')
-  end
-
-  [:before_http_request, :after_http_request].each do |hook|
-    specify "the #{hook} hook is only called once per request" do
-      call_count = 0
-      VCR.configuration.send(hook) { |r| call_count += 1 }
-
-      make_request
-      expect(call_count).to eq(1)
-    end
-
-    specify "the #{hook} hook yields the request" do
-      request = nil
-      VCR.configuration.send(hook) { |r| request = r }
-
-      make_request
-      expect(request.method).to be(:get)
-      expect(request.uri).to eq(request_url)
-    end
-
-    specify "the #{hook} hook is not called if the library hook is disabled" do
-      expect(VCR.library_hooks).to respond_to(:disabled?)
-      allow(VCR.library_hooks).to receive(:disabled?).and_return(true)
-
-      hook_called = false
-      VCR.configuration.send(hook) { |r| hook_called = true }
-
-      make_request(:disabled)
-      expect(hook_called).to be false
-    end
-
-    specify "the #type of the yielded request given to the #{hook} hook is #{request_type}" do
-      request = nil
-      VCR.configuration.send(hook) { |r| request = r }
-
-      make_request
-      expect(request.type).to be(request_type)
-    end
-  end
-
-  specify "the after_http_request hook yields the response if there is one and the second block arg is given" do
-    response = nil
-    VCR.configuration.after_http_request { |req, res| response = res }
-
-    make_request
-    assert_expected_response(response)
-  end
-end
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/sinatra_app.rb

@@ -1,86 +0,0 @@
-require 'sinatra'
-
-module VCR
-  class SinatraApp < ::Sinatra::Base
-    disable :protection
-
-    get '/' do
-      "GET to root"
-    end
-
-    get '/search' do
-      "query: #{params[:q]}"
-    end
-
-    get '/localhost_test' do
-      "Localhost response"
-    end
-
-    get '/foo' do
-      "FOO!"
-    end
-
-    get '/redirect-to-root' do
-      redirect to('/')
-    end
-
-    post '/foo' do
-      "FOO!"
-    end
-
-    post '/return-request-body' do
-      request.body
-    end
-
-    get '/set-cookie-headers/1' do
-      headers 'Set-Cookie' => 'foo'
-      'header set'
-    end
-
-    get '/set-cookie-headers/2' do
-      headers 'Set-Cookie' => %w[ bar foo ]
-      'header set'
-    end
-
-    get '/204' do
-      status 204
-    end
-
-    get '/404_not_200' do
-      status 404
-      '404 not 200'
-    end
-
-    # we use a global counter so that every response is different;
-    # this ensures that the test demonstrates that the response
-    # is being played back (and not running a 2nd real request)
-    $record_and_playback_response_count ||= 0
-    get '/record-and-playback' do
-      "Response #{$record_and_playback_response_count += 1}"
-    end
-
-    post '/record-and-playback' do
-      "Response #{$record_and_playback_response_count += 1}"
-    end
-
-    @_boot_failed = false
-
-    class << self
-      def port
-        server.port
-      end
-
-      def server
-        raise "Sinatra app failed to boot." if @_boot_failed
-        @server ||= begin
-          VCR::LocalhostServer.new(new)
-        rescue
-          @_boot_failed = true
-          raise
-        end
-      end
-
-      alias boot server
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/vcr_localhost_server.rb

@@ -1,77 +0,0 @@
-require 'rack'
-require 'rack/handler/webrick'
-require 'net/http'
-
-# The code for this is inspired by Capybara's server:
-#   http://github.com/jnicklas/capybara/blob/0.3.9/lib/capybara/server.rb
-module VCR
-  class LocalhostServer
-    READY_MESSAGE = "VCR server ready"
-
-    class Identify
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        if env["PATH_INFO"] == "/__identify__"
-          [200, {}, [VCR::LocalhostServer::READY_MESSAGE]]
-        else
-          @app.call(env)
-        end
-      end
-    end
-
-    attr_reader :port
-
-    def initialize(rack_app, port = nil)
-      @port = port || find_available_port
-      @rack_app = rack_app
-      concurrently { boot }
-      wait_until(10, "Boot failed.") { booted? }
-    end
-
-    private
-
-    def find_available_port
-      server = TCPServer.new('127.0.0.1', 0)
-      server.addr[1]
-    ensure
-      server.close if server
-    end
-
-    def boot
-      # Use WEBrick since it's part of the ruby standard library and is available on all ruby interpreters.
-      options = { :Port => port }
-      options.merge!(:AccessLog => [], :Logger => WEBrick::BasicLog.new(StringIO.new)) unless ENV['VERBOSE_SERVER']
-      Rack::Handler::WEBrick.run(Identify.new(@rack_app), options)
-    end
-
-    def booted?
-      res = ::Net::HTTP.get_response("localhost", '/__identify__', port)
-      if res.is_a?(::Net::HTTPSuccess) or res.is_a?(::Net::HTTPRedirection)
-        return res.body == READY_MESSAGE
-      end
-    rescue Errno::ECONNREFUSED, Errno::EBADF
-      return false
-    end
-
-    def concurrently
-      # JRuby doesn't support forking.
-      # Rubinius does, but there's a weird issue with the booted? check not working,
-      # so we're just using a thread for now.
-      Thread.new { yield }
-    end
-
-    def wait_until(timeout, error_message, &block)
-      start_time = Time.now
-
-      while true
-        return if yield
-        raise TimeoutError.new(error_message) if (Time.now - start_time) > timeout
-        sleep(0.05)
-      end
-    end
-  end
-end
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/vcr_stub_helpers.rb

@@ -1,17 +0,0 @@
-module VCRStubHelpers
-  def interactions_from(file)
-    hashes = YAML.load_file(File.join(VCR::SPEC_ROOT, 'fixtures', file))['http_interactions']
-    hashes.map { |h| VCR::HTTPInteraction.from_hash(h) }
-  end
-
-  def stub_requests(*args)
-    allow(VCR).to receive(:http_interactions).and_return(VCR::Cassette::HTTPInteractionList.new(*args))
-  end
-
-  def http_interaction(url, response_body = "FOO!", status_code = 200)
-    request = VCR::Request.new(:get, request_url)
-    response_status = VCR::ResponseStatus.new(status_code)
-    response = VCR::Response.new(response_status, nil, response_body, '1.1')
-    VCR::HTTPInteraction.new(request, response)
-  end
-end

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/vcr/cassette/erb_renderer_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe VCR::Cassette::ERBRenderer do
-  describe '#render' do
-    def render(*args)
-      described_class.new(*args).render
-    end
-
-    let(:no_vars_content) { '<%= 3 + 4 %>. Some ERB' }
-    let(:vars_content) { '<%= var1 %>. ERB with Vars! <%= var2 %>' }
-
-    context 'when ERB is disabled' do
-      it 'returns the given template' do
-        expect(render(no_vars_content, false)).to eq(no_vars_content)
-        expect(render(no_vars_content, nil)).to eq(no_vars_content)
-      end
-    end
-
-    context 'when ERB is enabled but no variables are passed' do
-      it 'renders the file content as ERB' do
-        expect(render(no_vars_content, true)).to eq("7. Some ERB")
-      end
-
-      it 'raises an appropriate error when the ERB template needs variables' do
-        expect {
-          render(vars_content, true, "vars")
-        }.to raise_error(VCR::Errors::MissingERBVariableError,
-          %{The ERB in the vars cassette file references undefined variable var1.  } +
-          %{Pass it to the cassette using :erb => #{ {:var1=>"some value"}.inspect }.}
-        )
-      end
-
-      it 'gracefully handles the template being nil' do
-        expect(render(nil, true)).to be_nil
-      end
-    end
-
-    context 'when ERB is enabled and variables are passed' do
-      it 'renders the file content as ERB with the passed variables' do
-        expect(render(vars_content, :var1 => 'foo', :var2 => 'bar')).to eq('foo. ERB with Vars! bar')
-      end
-
-      it 'raises an appropriate error when one or more of the needed variables are not passed' do
-        expect {
-          render(vars_content, { :var1 => 'foo' }, "vars")
-        }.to raise_error(VCR::Errors::MissingERBVariableError,
-          %{The ERB in the vars cassette file references undefined variable var2.  } +
-          %{Pass it to the cassette using :erb => #{ {:var1 => "foo", :var2 => "some value"}.inspect }.}
-        )
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/vcr/cassette/http_interaction_list_spec.rb

@@ -1,295 +0,0 @@
-require 'vcr/util/logger'
-require 'vcr/cassette/http_interaction_list'
-require 'vcr/request_matcher_registry'
-require 'vcr/structs'
-require 'support/configuration_stubbing'
-
-module VCR
-  class Cassette
-    describe HTTPInteractionList do
-      include_context "configuration stubbing"
-
-      ::RSpec::Matchers.define :respond_with do |expected|
-        match { |a| expected.nil? ? a.nil? : a.body == expected }
-      end
-
-      before(:each) do
-        allow(VCR).to receive(:request_matchers).and_return(VCR::RequestMatcherRegistry.new)
-        allow(config).to receive(:logger).and_return(double.as_null_object)
-      end
-
-      def request_with(values)
-        VCR::Request.new.tap do |request|
-          values.each do |name, value|
-            request.send("#{name}=", value)
-          end
-        end
-      end
-
-      def response(body)
-        VCR::Response.new.tap do |r|
-          r.body = body
-          r.status = VCR::ResponseStatus.new(200)
-        end
-      end
-
-      def interaction(body, request_values)
-        VCR::HTTPInteraction.new \
-          request_with(request_values),
-          response(body)
-      end
-
-      let(:original_list_array) do [
-        interaction('put response', :method => :put),
-        interaction('post response 1', :method => :post),
-        interaction('post response 2', :method => :post)
-      ] end
-
-      let(:allow_playback_repeats) { false } # the default
-      let(:list) { HTTPInteractionList.new(original_list_array, [:method], allow_playback_repeats) }
-
-      describe "#has_used_interaction_matching?" do
-        it 'returns false when no interactions have been used' do
-          expect(list).not_to have_used_interaction_matching(request_with(:method => :put))
-        end
-
-        it 'returns true when there is a matching used interaction (even if there is also an unused one that matches)' do
-          list.response_for(request_with(:method => :post))
-          expect(list).to have_used_interaction_matching(request_with(:method => :post))
-        end
-
-        it 'returns false when none of the used interactions match' do
-          list.response_for(request_with(:method => :put))
-          expect(list).not_to have_used_interaction_matching(request_with(:method => :post))
-        end
-      end
-
-      describe "#remaining_unused_interaction_count" do
-        it 'returns the number of unused interactions' do
-          expect(list.remaining_unused_interaction_count).to eq(3)
-
-          list.response_for(request_with(:method => :get))
-          expect(list.remaining_unused_interaction_count).to eq(3)
-
-          list.response_for(request_with(:method => :put))
-          expect(list.remaining_unused_interaction_count).to eq(2)
-
-          list.response_for(request_with(:method => :put))
-          expect(list.remaining_unused_interaction_count).to eq(2)
-
-          list.response_for(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(1)
-
-          list.response_for(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(0)
-
-          list.response_for(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(0)
-        end
-      end
-
-      describe "#assert_no_unused_interactions?" do
-        it 'should raise a SkippedHTTPRequestError when there are unused interactions left' do
-          expect {
-            list.assert_no_unused_interactions!
-          }.to raise_error(Errors::UnusedHTTPInteractionError)
-
-          list.response_for(request_with(:method => :put))
-          expect {
-            list.assert_no_unused_interactions!
-          }.to raise_error(Errors::UnusedHTTPInteractionError)
-        end
-
-        it 'should raise nothing when there are no unused interactions left' do
-          [:put, :post, :post].each do |method|
-            list.response_for(request_with(:method => method))
-          end
-
-          expect {
-            list.assert_no_unused_interactions!
-          }.not_to raise_error
-        end
-
-        context 'when the null logger is in use' do
-          before { allow(config).to receive(:logger).and_return(Logger::Null) }
-
-          it 'includes formatted request details in the error message' do
-            expect {
-              list.assert_no_unused_interactions!
-            }.to raise_error(/\[put/)
-          end
-
-          it 'includes formatted response details in the error message' do
-            expect {
-              list.assert_no_unused_interactions!
-            }.to raise_error(/\[200 "put response"\]/)
-          end
-        end
-      end
-
-      describe "has_interaction_matching?" do
-        it 'returns false when the list is empty' do
-          expect(HTTPInteractionList.new([], [:method])).not_to have_interaction_matching(double)
-        end
-
-        it 'returns false when there is no matching interaction' do
-          expect(list).not_to have_interaction_matching(request_with(:method => :get))
-        end
-
-        it 'returns true when there is a matching interaction' do
-          expect(list).to have_interaction_matching(request_with(:method => :post))
-        end
-
-        it 'does not consume the interactions when they match' do
-          expect(list).to have_interaction_matching(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(3)
-          expect(list).to have_interaction_matching(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(3)
-        end
-
-        it 'invokes each matcher block to find the matching interaction' do
-          VCR.request_matchers.register(:foo) { |r1, r2| true }
-          VCR.request_matchers.register(:bar) { |r1, r2| true }
-
-          calls = 0
-          VCR.request_matchers.register(:baz) { |r1, r2| calls += 1; calls == 2 }
-
-          list = HTTPInteractionList.new([
-            interaction('response', :method => :put)
-          ], [:foo, :bar, :baz])
-
-          expect(list).not_to have_interaction_matching(request_with(:method => :post))
-          expect(list).to     have_interaction_matching(request_with(:method => :post))
-        end
-
-        it "delegates to the parent list when it can't find a matching interaction" do
-          parent_list = double(:has_interaction_matching? => true)
-          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).to have_interaction_matching(double)
-          parent_list = double(:has_interaction_matching? => false)
-          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).not_to have_interaction_matching(double)
-        end
-
-        context 'when allow_playback_repeats is set to true' do
-          let(:allow_playback_repeats) { true }
-
-          it 'considers used interactions' do
-            list.response_for(request_with(:method => :put))
-
-            results = 10.times.map do
-              list.has_interaction_matching?(request_with(:method => :put))
-            end
-
-            expect(results).to eq([true] * 10)
-          end
-        end
-
-        context 'when allow_playback_repeats is set to false' do
-          let(:allow_playback_repeats) { false }
-
-          it 'does not consider used interactions' do
-            list.response_for(request_with(:method => :put))
-
-            result = 10.times.map do
-              list.has_interaction_matching?(request_with(:method => :put))
-            end
-
-            expect(result).to eq([false] * 10)
-          end
-        end
-      end
-
-      describe "#response_for" do
-        it 'returns nil when the list is empty' do
-          expect(HTTPInteractionList.new([], [:method]).response_for(double)).to respond_with(nil)
-        end
-
-        it 'returns nil when there is no matching interaction' do
-          response = HTTPInteractionList.new([
-            interaction('foo', :method => :post),
-            interaction('foo', :method => :put)
-          ], [:method]).response_for(
-            request_with(:method => :get)
-          )
-
-          expect(response).to respond_with(nil)
-        end
-
-        it 'returns the first matching interaction' do
-          list = HTTPInteractionList.new([
-            interaction('put response', :method => :put),
-            interaction('post response 1', :method => :post),
-            interaction('post response 2', :method => :post)
-          ], [:method])
-
-          expect(list.response_for(request_with(:method => :post))).to respond_with("post response 1")
-        end
-
-        it 'invokes each matcher block to find the matching interaction' do
-          VCR.request_matchers.register(:foo) { |r1, r2| true }
-          VCR.request_matchers.register(:bar) { |r1, r2| true }
-
-          calls = 0
-          VCR.request_matchers.register(:baz) { |r1, r2| calls += 1; calls == 2 }
-
-          list = HTTPInteractionList.new([
-            interaction('response', :method => :put)
-          ], [:foo, :bar, :baz])
-
-          expect(list.response_for(request_with(:method => :post))).to respond_with(nil)
-          expect(list.response_for(request_with(:method => :post))).to respond_with('response')
-        end
-
-        it "delegates to the parent list when it can't find a matching interaction" do
-          parent_list = double(:response_for => response('parent'))
-          result = HTTPInteractionList.new(
-            [], [:method], false, parent_list
-          ).response_for(double)
-
-          expect(result).to respond_with('parent')
-        end
-
-        it 'consumes the first matching interaction so that it will not be used again' do
-          expect(list.response_for(request_with(:method => :post)).body).to eq("post response 1")
-          expect(list.response_for(request_with(:method => :post)).body).to eq("post response 2")
-        end
-
-        context 'when allow_playback_repeats is set to true' do
-          let(:allow_playback_repeats) { true }
-
-          it 'continues to return the response from the last matching interaction when there are no more' do
-            list.response_for(request_with(:method => :post))
-
-            results = 10.times.map do
-              response = list.response_for(request_with(:method => :post))
-              response ? response.body : nil
-            end
-
-            expect(results).to eq(["post response 2"] * 10)
-          end
-        end
-
-        context 'when allow_playback_repeats is set to false' do
-          let(:allow_playback_repeats) { false }
-
-          it 'returns nil when there are no more unused interactions' do
-            list.response_for(request_with(:method => :post))
-            list.response_for(request_with(:method => :post))
-
-            results = 10.times.map do
-              list.response_for(request_with(:method => :post))
-            end
-
-            expect(results).to eq([nil] * 10)
-          end
-        end
-
-        it 'does not modify the original interaction array the list was initialized with' do
-          original_dup = original_list_array.dup
-          list.response_for(request_with(:method => :post))
-          expect(original_list_array).to eq original_dup
-        end
-      end
-    end
-  end
-end
-