social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/cassettes/format.feature

@@ -1,308 +0,0 @@
-Feature: Cassette format
-
-  VCR Cassettes are files that contain all of the information
-  about the requests and corresponding responses in a
-  human-readable/editable format.  A cassette contains an array
-  of HTTP interactions, each of which has the following:
-
-    - request
-      - method
-      - uri
-      - body
-        - encoding
-        - string
-      - headers
-    - response
-      - status
-        - code
-        - message
-      - headers
-      - body
-        - encoding
-        - string
-      - http version
-
-  By default, VCR uses YAML to serialize this data.  You can configure
-  VCR to use a different serializer, either on a cassette-by-cassette
-  basis, or as a default for all cassettes if you use the `default_cassette_options`.
-
-  VCR supports the following serializers out of the box:
-
-    - `:yaml`--Uses ruby's standard library YAML. This may use psych or syck,
-      depending on your ruby installation.
-    - `:syck`--Uses syck (the ruby 1.8 YAML engine). This is useful when using
-      VCR on a project that must run in environments where psych is not available
-      (such as on ruby 1.8), to ensure that syck is always used.
-    - `:psych`--Uses psych (the new ruby 1.9 YAML engine). This is useful when
-      you want to ensure that psych is always used.
-    - `:json`--Uses [multi_json](https://github.com/intridea/multi_json)
-      to serialize the cassette data as JSON.
-
-  You can also register a custom serializer using:
-
-       VCR.configure do |config|
-         config.cassette_serializers[:my_custom_serializer] = my_serializer
-       end
-
-  Your serializer must implement the following methods:
-
-    - `file_extension`
-    - `serialize(hash)`
-    - `deserialize(string)`
-
-  Scenario Outline: Request/Response data is saved to disk as YAML by default
-    Given a file named "cassette_yaml.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      if ARGV.any?
-        start_sinatra_app(:port => 7777) do
-          get('/:path') { ARGV[0] + ' ' + params[:path] }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example') do
-        make_http_request(:get, "http://localhost:7777/foo", nil, 'Accept-Encoding' => 'identity')
-        make_http_request(:get, "http://localhost:7777/bar", nil, 'Accept-Encoding' => 'identity')
-      end
-      """
-    When I run `ruby cassette_yaml.rb 'Hello'`
-    Then the file "cassettes/example.yml" should contain YAML like:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost:7777/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: 
-            Accept-Encoding: 
-            - identity
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello foo
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bar
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: 
-            Accept-Encoding: 
-            - identity
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello bar
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :webmock  | httpclient            |
-      | c.hook_into :webmock  | patron                |
-      | c.hook_into :webmock  | curb                  |
-      | c.hook_into :webmock  | em-http-request       |
-      | c.hook_into :webmock  | typhoeus              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :excon    | excon                 |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-
-  Scenario: Request/Response data can be saved as JSON
-    Given a file named "cassette_json.rb" with:
-      """ruby
-      include_http_adapter_for("net/http")
-
-      start_sinatra_app(:port => 7777) do
-        get('/:path') { ARGV[0] + ' ' + params[:path] }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example', :serialize_with => :json) do
-        puts response_body_for(:get, "http://localhost:7777/foo", nil, 'Accept-Encoding' => 'identity')
-        puts response_body_for(:get, "http://localhost:7777/bar", nil, 'Accept-Encoding' => 'identity')
-      end
-      """
-    When I run `ruby cassette_json.rb 'Hello'`
-    Then the file "cassettes/example.json" should contain JSON like:
-      """json
-      {
-        "http_interactions": [
-          {
-            "response": {
-              "body": {
-                "encoding": "UTF-8",
-                "string": "Hello foo"
-              },
-              "http_version": null,
-              "status": { "code": 200, "message": "OK" },
-              "headers": {
-                "Date": [ "Thu, 27 Oct 2011 06:16:31 GMT" ],
-                "Content-Type": [ "text/html;charset=utf-8" ],
-                "Content-Length": [ "9" ],
-                "Server": [ "WEBrick/1.3.1 (Ruby/1.8.7/2011-06-30)" ],
-                "Connection": [ "Keep-Alive" ]
-              }
-            },
-            "request": {
-              "uri": "http://localhost:7777/foo",
-              "body": {
-                "encoding": "UTF-8",
-                "string": ""
-              },
-              "method": "get",
-              "headers": {
-                "Accept-Encoding": [ "identity" ]
-              }
-            },
-            "recorded_at": "Tue, 01 Nov 2011 04:58:44 GMT"
-          },
-          {
-            "response": {
-              "body": {
-                "encoding": "UTF-8",
-                "string": "Hello bar"
-              },
-              "http_version": null,
-              "status": { "code": 200, "message": "OK" },
-              "headers": {
-                "Date": [ "Thu, 27 Oct 2011 06:16:31 GMT" ],
-                "Content-Type": [ "text/html;charset=utf-8" ],
-                "Content-Length": [ "9" ],
-                "Server": [ "WEBrick/1.3.1 (Ruby/1.8.7/2011-06-30)" ],
-                "Connection": [ "Keep-Alive" ]
-              }
-            },
-            "request": {
-              "uri": "http://localhost:7777/bar",
-              "body": {
-                "encoding": "UTF-8",
-                "string": ""
-              },
-              "method": "get",
-              "headers": {
-                "Accept-Encoding": [ "identity" ]
-              }
-            },
-            "recorded_at": "Tue, 01 Nov 2011 04:58:44 GMT"
-          }
-        ],
-        "recorded_with": "VCR 2.0.0"
-      }
-      """
-    When I run `ruby cassette_json.rb`
-    Then it should pass with:
-      """
-      Hello foo
-      Hello bar
-      """
-
-  Scenario: Request/Response data can be saved using a custom serializer
-    Given a file named "cassette_ruby.rb" with:
-      """ruby
-      include_http_adapter_for("net/http")
-
-      start_sinatra_app(:port => 7777) do
-        get('/:path') { ARGV[0] + ' ' + params[:path] }
-      end
-
-      require 'vcr'
-
-      # purely for demonstration purposes; obviously, don't actually
-      # use ruby #inspect / #eval for your serialization...
-      ruby_serializer = Object.new
-      class << ruby_serializer
-        def file_extension; "ruby"; end
-        def serialize(hash); hash.inspect; end
-        def deserialize(string); eval(string); end
-      end
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.cassette_serializers[:ruby] = ruby_serializer
-      end
-
-      VCR.use_cassette('example', :serialize_with => :ruby) do
-        puts response_body_for(:get, "http://localhost:7777/foo", nil, 'Accept-Encoding' => 'identity')
-        puts response_body_for(:get, "http://localhost:7777/bar", nil, 'Accept-Encoding' => 'identity')
-      end
-      """
-    When I run `ruby cassette_ruby.rb 'Hello'`
-    Then the file "cassettes/example.ruby" should contain ruby like:
-      """
-      {"http_interactions"=>
-        [{"request"=>
-           {"method"=>"get",
-            "uri"=>"http://localhost:7777/foo",
-            "body"=>{"encoding"=>"UTF-8", "string"=>""},
-            "headers"=>{"Accept"=>["*/*"], "Accept-Encoding"=>["identity"], "User-Agent"=>["Ruby"]}},
-          "response"=>
-           {"status"=>{"code"=>200, "message"=>"OK "},
-            "headers"=>
-             {"Content-Type"=>["text/html;charset=utf-8"],
-              "Content-Length"=>["9"],
-              "Connection"=>["Keep-Alive"]},
-            "body"=>{"encoding"=>"UTF-8", "string"=>"Hello foo"},
-            "http_version"=>nil},
-          "recorded_at"=>"Tue, 01 Nov 2011 04:58:44 GMT"},
-         {"request"=>
-           {"method"=>"get",
-            "uri"=>"http://localhost:7777/bar",
-            "body"=>{"encoding"=>"UTF-8", "string"=>""},
-            "headers"=>{"Accept"=>["*/*"], "Accept-Encoding"=>["identity"], "User-Agent"=>["Ruby"]}},
-          "response"=>
-           {"status"=>{"code"=>200, "message"=>"OK "},
-            "headers"=>
-             {"Content-Type"=>["text/html;charset=utf-8"],
-              "Content-Length"=>["9"],
-              "Connection"=>["Keep-Alive"]},
-            "body"=>{"encoding"=>"UTF-8", "string"=>"Hello bar"},
-            "http_version"=>nil},
-          "recorded_at"=>"Tue, 01 Nov 2011 04:58:44 GMT"}],
-       "recorded_with"=>"VCR 2.0.0"}
-      """
-    When I run `ruby cassette_ruby.rb`
-    Then it should pass with:
-      """
-      Hello foo
-      Hello bar
-      """

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/cassettes/freezing_time.feature

@@ -1,68 +0,0 @@
-Feature: Freezing Time
-
-  When dealing with an HTTP API that includes time-based compontents
-  in the request (e.g. for signed S3 requests), it can be useful
-  on playback to freeze time to what it originally was when the
-  cassette was recorded so that the request is always the same
-  each time your test is run.
-
-  While VCR doesn't directly support time freezing, it does
-  expose `VCR::Cassette#originally_recorded_at`, which you can
-  easily use with a library like
-  [timecop](https://github.com/travisjeffery/timecop)
-  to freeze time.
-
-  Note: `VCR::Cassette#originally_recorded_at` will return `nil`
-  when the cassette is recording for the first time, so you'll
-  probably want to use an expression like
-  `cassette.originally_recorded_at || Time.now` so that it
-  will work when recording or when playing back.
-
-  Scenario: Previously recorded responses are replayed
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/events/since/2013-09-23T17:00:30Z
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "20"
-          body: 
-            encoding: UTF-8
-            string: Some Event
-          http_version: "1.1"
-        recorded_at: Mon, 23 Sep 2013 17:00:30 GMT
-      recorded_with: VCR 2.0.0
-      """
-    Given a file named "freeze_time.rb" with:
-      """ruby
-      require 'time'
-      require 'timecop'
-      require 'vcr'
-
-      VCR.configure do |vcr|
-        vcr.cassette_library_dir = 'cassettes'
-        vcr.hook_into :webmock
-      end
-
-      VCR.use_cassette('example') do |cassette|
-        Timecop.freeze(cassette.originally_recorded_at || Time.now) do
-          path = "/events/since/#{Time.now.getutc.iso8601}"
-          response = Net::HTTP.get_response('example.com', path)
-          puts "Response: #{response.body}"
-        end
-      end
-      """
-    When I run `ruby freeze_time.rb`
-    Then it should pass with "Response: Some Event"
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/cassettes/naming.feature

@@ -1,28 +0,0 @@
-Feature: Naming
-
-  When inserting or using a cassette, the first argument is the cassette name.
-  You can use any string for the name.  If you use the default `:file_system`
-  storage backend, VCR will sanitize the string before using it as a file name,
-  so that it is a file-system friendly file name.
-
-  Scenario: Name sanitizing
-    Given a file named "name_sanitizing.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-      end
-
-      VCR.use_cassette('Fee, Fi Fo Fum') do
-        Net::HTTP.get_response('localhost', '/', 7777)
-      end
-      """
-     And the directory "cassettes" does not exist
-    When I run `ruby name_sanitizing.rb`
-    Then the file "cassettes/Fee_Fi_Fo_Fum.yml" should contain "Hello"

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/cassettes/no_cassette.feature

@@ -1,152 +0,0 @@
-Feature: Error for HTTP request made when no cassette is in use
-
-  VCR is designed to help you remove all HTTP dependencies from your
-  test suite.  To assist with this, VCR will cause an exception to be
-  raised when an HTTP request is made while there is no cassette in
-  use.  The error is helpful to pinpoint where HTTP requests are
-  made so you can use a VCR cassette at that point in your code.
-
-  If you want insight about how VCR attempted to handle the request,
-  you can use the [debug\_logger](../configuration/debug-logging)
-  configuration option to log more details.
-
-  If you want to allow an HTTP request to proceed as normal, you can
-  set the [allow\_http\_connections\_when\_no\_cassette](../configuration/allow-http-connections-when-no-cassette)
-  configuration option or you can temporarily turn VCR off:
-
-    - `VCR.turn_off!` => turn VCR off so HTTP requests are allowed.
-      Cassette insertions will trigger an error.
-    - `VCR.turn_off!(:ignore_cassettes => true)` => turn
-      VCR off and ignore cassette insertions (so that no error is raised).
-    - `VCR.turn_on!` => turn VCR back on
-    - `VCR.turned_off { ... }` => turn VCR off for the duration of the
-      provided block.
-
-  @exclude-jruby
-  Scenario Outline: Error for request when no cassette is in use
-    Given a file named "no_cassette_error.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      response_body_for(:get, 'http://example.com/')
-      """
-    When I run `ruby no_cassette_error.rb`
-    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :webmock  | httpclient            |
-      | c.hook_into :webmock  | curb                  |
-      | c.hook_into :webmock  | patron                |
-      | c.hook_into :webmock  | em-http-request       |
-      | c.hook_into :webmock  | typhoeus              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :excon    | excon                 |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-
-  Scenario: Temporarily turn VCR off to allow HTTP requests to procede as normal
-    Given a file named "turn_off_vcr.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { 'Hello' }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-      end
-      WebMock.allow_net_connect!
-
-      def make_request(context)
-        puts context
-        puts Net::HTTP.get_response('localhost', '/', 7777).body
-      rescue => e
-        puts "Error: #{e.class}"
-      end
-
-      VCR.turned_off do
-        make_request "In VCR.turned_off block"
-      end
-
-      make_request "Outside of VCR.turned_off block"
-
-      VCR.turn_off!
-      make_request "After calling VCR.turn_off!"
-
-      VCR.turn_on!
-      make_request "After calling VCR.turn_on!"
-      """
-    When I run `ruby turn_off_vcr.rb`
-    Then the output should contain:
-      """
-      In VCR.turned_off block
-      Hello
-      """
-    And the output should contain:
-      """
-      Outside of VCR.turned_off block
-      Error: VCR::Errors::UnhandledHTTPRequestError
-      """
-    And the output should contain:
-      """
-      After calling VCR.turn_off!
-      Hello
-      """
-    And the output should contain:
-      """
-      After calling VCR.turn_on!
-      Error: VCR::Errors::UnhandledHTTPRequestError
-      """
-
-  Scenario: Turning VCR off prevents cassettes from being inserted
-    Given a file named "turn_off_vcr_and_insert_cassette.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-      end
-      WebMock.allow_net_connect!
-
-      VCR.turn_off!
-      VCR.insert_cassette('example')
-      """
-    When I run `ruby turn_off_vcr_and_insert_cassette.rb`
-    Then it should fail with "VCR is turned off.  You must turn it on before you can insert a cassette."
-
-  Scenario: Turning VCR off with `:ignore_cassettes => true` ignores cassettes
-    Given a file named "turn_off_vcr_and_insert_cassette.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { 'Hello' }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-      end
-      WebMock.allow_net_connect!
-
-      VCR.turn_off!(:ignore_cassettes => true)
-
-      VCR.use_cassette('example') do
-        response = Net::HTTP.get_response('localhost', '/', 7777).body
-        puts "Response: #{response}"
-      end
-      """
-    When I run `ruby turn_off_vcr_and_insert_cassette.rb`
-    Then it should pass with "Response: Hello"
-     And the file "cassettes/example.yml" should not exist
-