dwolla_swagger 1.0.6 → 1.0.7

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/support/env.rb

@@ -1,41 +0,0 @@
-require 'rubygems'
-require 'bundler'
-Bundler.setup
-
-require 'ruby-debug' if !defined?(RUBY_ENGINE) && RUBY_VERSION != '1.9.3' && !ENV['CI']
-
-require 'aruba/cucumber'
-require 'aruba/jruby' if RUBY_PLATFORM == 'java'
-
-additional_paths = []
-Before('@rspec-1') do
-  additional_paths << File.join(%w[ .. .. vendor rspec-1 bin ])
-end
-
-Before do
-  load_paths, requires = ['../../lib'], []
-
-  # Put any bundler-managed gems (such as :git gems) on the load path for when aruba shells out.
-  # Alternatively, we could hook up aruba to use bundler when it shells out, but invoking bundler
-  # for each and every time aruba starts ruby would slow everything down. We really only need it for
-  # bundler-managed gems.
-  load_paths.push($LOAD_PATH.grep %r|bundler/gems|)
-
-  if RUBY_VERSION < '1.9'
-    requires << "rubygems"
-  else
-    load_paths << '.'
-  end
-
-  requires << '../../features/support/vcr_cucumber_helpers'
-  requires.map! { |r| "-r#{r}" }
-  set_env('RUBYOPT', "-I#{load_paths.join(':')} #{requires.join(' ')}")
-
-  if additional_paths.any?
-    existing_paths = ENV['PATH'].split(':')
-    set_env('PATH', (additional_paths + existing_paths).join(':'))
-  end
-
-  @aruba_timeout_seconds = 60
-end
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/support/http_lib_filters.rb

@@ -1,53 +0,0 @@
-# make the values of the example row cells available as an array...
-Cucumber::Ast::OutlineTable::ExampleRow.class_eval do
-  def cell_values
-    @cells.map { |c| c.value  }
-  end
-end
-
-if RUBY_VERSION == '1.8.7'
-  # We get timeouts on 1.8.7 w/ Patron for some reason.
-  UNSUPPORTED_HTTP_LIBS = %w[ patron ]
-elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-  # Patron is freezing up the cukes (as it does on 1.9.2)
-
-  # I'm not sure why em-http-request isn't working on rbx,
-  # but considering the fact that VCR works with all the other
-  # libs just fine and doesn't do anything for em-http-request,
-  # it's probably a bug in it or rbx...so ignore it, for now.
-
-  # I'm getting errors in the curb C extension in rbx.
-
-  # Faraday and Typhoeus should be buildable on rbx, but the travis build times out,
-  # so we skip them to speed up the build on travis.
-  UNSUPPORTED_HTTP_LIBS = %w[ patron em-http-request curb faraday typhoeus ]
-elsif RUBY_PLATFORM == 'java'
-  # These gems have C extensions and can't install on JRuby.
-  c_dependent_libs = %w[ typhoeus patron curb em-http-request ]
-
-  # The latest version of httpclient seems to freeze up the cukes
-  # on JRuby.  I'm not sure why, and there's little benefit to running
-  # them on JRuby...so we just skip them.  Excon seems to have the same issue :(.
-  UNSUPPORTED_HTTP_LIBS = c_dependent_libs + %w[ httpclient excon ]
-end
-
-if defined?(UNSUPPORTED_HTTP_LIBS)
-  UNSUPPORTED_HTTP_LIB_REGEX = Regexp.union(*UNSUPPORTED_HTTP_LIBS)
-
-  # Filter out example rows that use libraries that are not supported on the current ruby interpreter
-  Around do |scenario, block|
-    unless scenario.respond_to?(:cell_values) && scenario.cell_values.any? { |v| v =~ UNSUPPORTED_HTTP_LIB_REGEX }
-      block.call
-    end
-  end
-end
-
-# Set a global based on the current stubbing lib so we can put special-case
-# logic in our step definitions based on the http stubbing library.
-Before do |scenario|
-  if scenario.respond_to?(:cell_values)
-    @scenario_parameters = scenario.cell_values
-  else
-    @scenario_parameters = nil
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/support/vcr_cucumber_helpers.rb

@@ -1,46 +0,0 @@
-require 'date'
-
-# This file gets symlinked into the tmp/aruba directory before
-# each scenario so that it is available to be required in them.
-$LOAD_PATH << '../../spec' unless $LOAD_PATH.include?('../../spec')
-$LOAD_PATH.unshift '../../lib'  unless $LOAD_PATH.include?('../../lib')
-
-running_under_aruba = File.expand_path('.').include?('aruba')
-if running_under_aruba
-  require 'support/fixnum_extension'
-  require 'vcr/util/internet_connection'
-
-  # pretend we're always on the internet (so that we don't have an
-  # internet connection dependency for our cukes)
-  VCR::InternetConnection.class_eval do
-    def available?; true; end
-  end
-end
-
-if ENV['DATE_STRING']
-  require 'timecop'
-  Timecop.travel(Date.parse(ENV['DATE_STRING']))
-end
-
-def include_http_adapter_for(lib)
-  require (lib =~ /faraday/ ? 'faraday' : lib)
-  require 'typhoeus' if lib.include?('typhoeus') # for faraday-typhoeus
-  require 'support/http_library_adapters'
-  include HTTP_LIBRARY_ADAPTERS[lib]
-end
-
-def response_body_for(*args)
-  get_body_string(make_http_request(*args))
-end
-
-def start_sinatra_app(options, &block)
-  raise ArgumentError.new("You must pass a port") unless options[:port]
-
-  require 'sinatra'
-  require 'support/vcr_localhost_server'
-  klass = Class.new(Sinatra::Base)
-  klass.disable :protection
-  klass.class_eval(&block)
-
-  VCR::LocalhostServer.new(klass.new, options[:port])
-end

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/test_frameworks/cucumber.feature

@@ -1,210 +0,0 @@
-Feature: Usage with Cucumber
-
-  VCR can be used with cucumber in two basic ways:
-
-    - Use `VCR.use_cassette` in a step definition.
-    - Use a `VCR.cucumber_tags` block to tell VCR to use a
-      cassette for a tagged scenario.
-
-  In a cucumber support file (e.g. features/support/vcr.rb), put code like this:
-
-  ``` ruby
-  VCR.cucumber_tags do |t|
-    t.tag  '@tag1'
-    t.tags '@tag2', '@tag3'
-
-    t.tag  '@tag3', :cassette => :options
-    t.tags '@tag4', '@tag5', :cassette => :options
-    t.tag  '@vcr', :use_scenario_name => true
-  end
-  ```
-
-  VCR will use a cassette named `cucumber_tags/<tag_name>` for scenarios
-  with each of these tags (Unless the `:use_scenario_name` option is provided. See below).
-  The configured `default_cassette_options` will be used, or you can override specific
-  options by passing a hash as the last argument to `#tag` or `#tags`.
-
-  You can also have VCR name your cassettes automatically according to the feature
-  and scenario name by providing `:use_scenario_name => true` to `#tag` or `#tags`.
-  In this case, the cassette will be named `<feature_name>/<scenario_name>`.
-  For scenario outlines, VCR will record one cassette per row, and the cassettes
-  will be named `<feature_name>/<scenario_name>/<row_name>`.
-
-  @exclude-jruby
-  Scenario: Record HTTP interactions in a scenario by tagging it
-    Given a file named "lib/server.rb" with:
-      """ruby
-      if ENV['WITH_SERVER'] == 'true'
-        start_sinatra_app(:port => 7777) do
-          get('/:path') { "Hello #{params[:path]}" }
-        end
-      end
-      """
-
-    Given a file named "features/support/vcr.rb" with:
-      """ruby
-      require "lib/server"
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir     = 'features/cassettes'
-      end
-
-      VCR.cucumber_tags do |t|
-        t.tag  '@localhost_request' # uses default record mode since no options are given
-        t.tags '@disallowed_1', '@disallowed_2', :record => :none
-        t.tag  '@vcr', :use_scenario_name => true
-      end
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """ruby
-      require 'net/http'
-
-      When /^a request is made to "([^"]*)"$/ do |url|
-        @response = Net::HTTP.get_response(URI.parse(url))
-      end
-
-      When /^(.*) within a cassette named "([^"]*)"$/ do |step, cassette_name|
-        VCR.use_cassette(cassette_name) { When step }
-      end
-
-      Then /^the response should be "([^"]*)"$/ do |expected_response|
-        @response.body.should == expected_response
-      end
-      """
-    And a file named "features/vcr_example.feature" with:
-      """
-      Feature: VCR example
-
-        Note: Cucumber treats the pre-amble as part of the feature name. When
-        using the :use_scenario_name option, VCR will only use the first line
-        of the feature name as the directory for the cassette.
-
-        @localhost_request
-        Scenario: tagged scenario
-          When a request is made to "http://localhost:7777/localhost_request_1"
-          Then the response should be "Hello localhost_request_1"
-          When a request is made to "http://localhost:7777/nested_cassette" within a cassette named "nested_cassette"
-          Then the response should be "Hello nested_cassette"
-          When a request is made to "http://localhost:7777/localhost_request_2"
-          Then the response should be "Hello localhost_request_2"
-
-        @vcr
-        Scenario: tagged scenario
-
-        Note: Like the feature pre-amble, Cucumber treats the scenario pre-amble
-        as part of the scenario name. When using the :use_scenario_name option,
-        VCR will only use the first line of the feature name as the directory
-        for the cassette.
-
-          When a request is made to "http://localhost:7777/localhost_request_1"
-          Then the response should be "Hello localhost_request_1"
-
-        @vcr
-        Scenario Outline: tagged scenario outline
-          When a request is made to "http://localhost:7777/localhost_request_1"
-          Then the response should be "Hello localhost_request_1"
-          Examples:
-            | key  | value |
-            | foo  | bar   |
-
-        @disallowed_1
-        Scenario: tagged scenario
-          When a request is made to "http://localhost:7777/allowed" within a cassette named "allowed"
-          Then the response should be "Hello allowed"
-          When a request is made to "http://localhost:7777/disallowed_1"
-
-        @disallowed_2
-        Scenario: tagged scenario
-          When a request is made to "http://localhost:7777/disallowed_2"
-      """
-    And the directory "features/cassettes" does not exist
-    When I run `cucumber WITH_SERVER=true features/vcr_example.feature`
-    Then it should fail with "5 scenarios (2 failed, 3 passed)"
-    And the output should contain each of the following:
-      | An HTTP request has been made that VCR does not know how to handle:               |
-      |   GET http://localhost:7777/disallowed_1                                          |
-      | An HTTP request has been made that VCR does not know how to handle:               |
-      |   GET http://localhost:7777/disallowed_2                                          |
-    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "Hello localhost_request_1"
-    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "Hello localhost_request_2"
-    And the file "features/cassettes/nested_cassette.yml" should contain "Hello nested_cassette"
-    And the file "features/cassettes/allowed.yml" should contain "Hello allowed"
-    And the file "features/cassettes/VCR_example/tagged_scenario.yml" should contain "Hello localhost_request_1"
-    And the file "features/cassettes/VCR_example/tagged_scenario_outline/_foo_bar_.yml" should contain "Hello localhost_request_1"
-
-    # Run again without the server; we'll get the same responses because VCR
-    # will replay the recorded responses.
-    When I run `cucumber features/vcr_example.feature`
-    Then it should fail with "5 scenarios (2 failed, 3 passed)"
-    And the output should contain each of the following:
-      | An HTTP request has been made that VCR does not know how to handle:               |
-      |   GET http://localhost:7777/disallowed_1                                          |
-      | An HTTP request has been made that VCR does not know how to handle:               |
-      |   GET http://localhost:7777/disallowed_2                                          |
-    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "Hello localhost_request_1"
-    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "Hello localhost_request_2"
-    And the file "features/cassettes/nested_cassette.yml" should contain "Hello nested_cassette"
-    And the file "features/cassettes/allowed.yml" should contain "Hello allowed"
-    And the file "features/cassettes/VCR_example/tagged_scenario.yml" should contain "Hello localhost_request_1"
-    And the file "features/cassettes/VCR_example/tagged_scenario_outline/_foo_bar_.yml" should contain "Hello localhost_request_1"
-
-  Scenario: `:allow_unused_http_interactions => false` does not raise if the scenario already failed
-    Given a previously recorded cassette file "features/cassettes/cucumber_tags/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "5"
-          body: 
-            encoding: UTF-8
-            string: Hello
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "features/support/vcr.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'features/cassettes'
-      end
-
-      VCR.cucumber_tags do |t|
-        t.tag '@example', :allow_unused_http_interactions => false
-      end
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """ruby
-      When /^the scenario fails$/ do
-        raise "boom"
-      end
-      """
-    And a file named "features/vcr_example.feature" with:
-      """
-      Feature:
-
-        @example
-        Scenario: tagged scenario
-          When the scenario fails
-      """
-    When I run `cucumber features/vcr_example.feature`
-    Then it should fail with "1 scenario (1 failed)"
-     And the output should contain "boom"
-     And the output should not contain "There are unused HTTP interactions"
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/test_frameworks/rspec_macro.feature

@@ -1,106 +0,0 @@
-Feature: Usage with RSpec macro
-
-  VCR provides a macro that makes it easy to use a VCR cassette for an RSpec
-  example group.  To use it, simply add `config.extend VCR::RSpec::Macros`
-  to your RSpec configuration block.
-
-  In any example group, add a `use_vcr_cassette` declaration to use a cassette
-  for that example group.  You can use this in a few different ways:
-
-    - `use_vcr_cassette`
-      - Infers a cassette name from the example group description (and parent
-        example group descriptions).
-      - Uses the `default_cassette_options` you have configured.
-    - `use_vcr_cassette "Cassette Name"`
-      - Uses the given cassette name.
-      - Uses the `default_cassette_options` you have configured.
-    - `use_vcr_cassette :cassette => :options`
-      - Infers a cassette name from the example group description (and parent
-        example group descriptions).
-      - Uses the provided cassette options (merged with the defaults).
-    - `use_vcr_cassette "Cassette Name", :cassette => :options`
-      - Uses the given cassette name.
-      - Uses the provided cassette options (merged with the defaults).
-
-  Background:
-    Given the following files do not exist:
-        | spec/cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml |
-        | spec/cassettes/net_http_example.yml                                        |
-    And a file named "spec/sinatra_app.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello" }
-      end
-      """
-    And a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      describe "VCR-RSpec integration" do
-        def make_http_request
-          Net::HTTP.get_response('localhost', '/', 7777).body
-        end
-
-        context "without an explicit cassette name" do
-          use_vcr_cassette
-
-          it 'records an http request' do
-            make_http_request.should == 'Hello'
-          end
-        end
-
-        context "with an explicit cassette name" do
-          use_vcr_cassette "net_http_example"
-
-          it 'records an http request' do
-            make_http_request.should == 'Hello'
-          end
-        end
-      end
-      """
-
-  Scenario: Use `use_vcr_cassette` macro with RSpec 2
-    Given a file named "spec/spec_helper.rb" with:
-      """ruby
-      require 'sinatra_app'
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'spec/cassettes'
-        c.hook_into :webmock
-      end
-
-      RSpec.configure do |c|
-        c.extend VCR::RSpec::Macros
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then the output should contain "2 examples, 0 failures"
-     And the file "spec/cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml" should contain "Hello"
-     And the file "spec/cassettes/net_http_example.yml" should contain "Hello"
-
-  @rspec-1 @exclude-jruby
-  Scenario: Use `use_vcr_cassette` macro with RSpec 1
-    Given a file named "spec/spec_helper.rb" with:
-      """ruby
-      require 'sinatra_app'
-
-      require 'spec'
-      require 'spec/autorun'
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'spec/cassettes'
-        c.hook_into :webmock
-      end
-
-      Spec::Runner.configure do |c|
-        c.extend VCR::RSpec::Macros
-      end
-      """
-    When I run `spec spec/vcr_example_spec.rb`
-    Then the output should contain "2 examples, 0 failures"
-     And the file "spec/cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml" should contain "Hello"
-     And the file "spec/cassettes/net_http_example.yml" should contain "Hello"
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/test_frameworks/rspec_metadata.feature

@@ -1,149 +0,0 @@
-Feature: Usage with RSpec metadata
-
-  VCR provides easy integration with RSpec using metadata. To set this
-  up, call `configure_rspec_metadata!` in your `VCR.configure` block.
-
-  Once you've done that, you can have an example group or example use
-  VCR by passing `:vcr` as an additional argument after the description
-  string. It will set the cassette name based on the example's
-  full description.
-
-  If you need to override the cassette name or options, you can pass a
-  hash (`:vcr => { ... }`).
-
-  Background:
-    Given a file named "spec/spec_helper.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'spec/cassettes'
-        c.hook_into :webmock
-        c.configure_rspec_metadata!
-      end
-
-      RSpec.configure do |c|
-        # so we can use `:vcr` rather than `:vcr => true`;
-        # in RSpec 3 this will no longer be necessary.
-        c.treat_symbols_as_metadata_keys_with_true_values = true
-      end
-      """
-    And a previously recorded cassette file "spec/cassettes/Group/optionally_raises_an_error.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "5"
-          body: 
-            encoding: UTF-8
-            string: Hello
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario: Use `:vcr` metadata
-    Given a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello" }
-      end
-
-      def make_http_request
-        Net::HTTP.get_response('localhost', '/', 7777).body
-      end
-
-      require 'spec_helper'
-
-      describe "VCR example group metadata", :vcr do
-        it 'records an http request' do
-          make_http_request.should == 'Hello'
-        end
-
-        it 'records another http request' do
-          make_http_request.should == 'Hello'
-        end
-
-        context 'in a nested example group' do
-          it 'records another one' do
-            make_http_request.should == 'Hello'
-          end
-        end
-      end
-
-      describe "VCR example metadata" do
-        it 'records an http request', :vcr do
-          make_http_request.should == 'Hello'
-        end
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then it should pass with "4 examples, 0 failures"
-     And the file "spec/cassettes/VCR_example_group_metadata/records_an_http_request.yml" should contain "Hello"
-     And the file "spec/cassettes/VCR_example_group_metadata/records_another_http_request.yml" should contain "Hello"
-     And the file "spec/cassettes/VCR_example_group_metadata/in_a_nested_example_group/records_another_one.yml" should contain "Hello"
-     And the file "spec/cassettes/VCR_example_metadata/records_an_http_request.yml" should contain "Hello"
-
-  Scenario: `:allow_unused_http_interactions => false` causes a failure if there are unused interactions
-    And a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      describe "Group", :vcr => { :allow_unused_http_interactions => false } do
-        it 'optionally raises an error' do
-          # don't fail
-        end
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then it should fail with an error like:
-      """
-      There are unused HTTP interactions left in the cassette:
-        - [get http://example.com/foo] => [200 "Hello"]
-      """
-
-  Scenario: `:allow_unused_http_interactions => false` does not raise if the example already failed
-    And a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      describe "Group", :vcr => { :allow_unused_http_interactions => false } do
-        it 'optionally raises an error' do
-          raise "boom"
-        end
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then it should fail with "boom"
-     And the output should not contain "There are unused HTTP interactions"
-
-  Scenario: Pass a hash to set the cassette options
-    Given a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      vcr_options = { :cassette_name => "example", :record => :new_episodes }
-      describe "Using an options hash", :vcr => vcr_options do
-        it 'uses the provided cassette name' do
-          VCR.current_cassette.name.should == "example"
-        end
-
-        it 'sets the given options' do
-          VCR.current_cassette.record_mode.should == :new_episodes
-        end
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then it should pass with "2 examples, 0 failures"

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/test_frameworks/test_unit.feature

@@ -1,46 +0,0 @@
-Feature: Usage with Test::Unit
-
-  To use VCR with Test::Unit, wrap the body of any test method in
-  `VCR.use_cassette`.
-
-  Scenario: Use `VCR.use_cassette` in a test
-    Given a file named "test/test_server.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello" }
-      end
-      """
-    Given a file named "test/test_helper.rb" with:
-      """ruby
-      require 'test/test_server' if ENV['SERVER'] == 'true'
-      require 'test/unit'
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'test/fixtures/vcr_cassettes'
-      end
-      """
-    And a file named "test/vcr_example_test.rb" with:
-      """ruby
-      require 'test_helper'
-
-      class VCRExampleTest < Test::Unit::TestCase
-        def test_use_vcr
-          VCR.use_cassette('test_unit_example') do
-            response = Net::HTTP.get_response('localhost', '/', 7777)
-            assert_equal "Hello", response.body
-          end
-        end
-      end
-      """
-    And the directory "test/fixtures/vcr_cassettes" does not exist
-    When I set the "SERVER" environment variable to "true"
-     And I run `ruby -Itest test/vcr_example_test.rb`
-    Then it should pass with "1 tests, 1 assertions, 0 failures, 0 errors"
-    And the file "test/fixtures/vcr_cassettes/test_unit_example.yml" should contain "Hello"
-
-    # Run again without starting the sinatra server so the response will be replayed
-    When I set the "SERVER" environment variable to "false"
-     And I run `ruby -Itest test/vcr_example_test.rb`
-    Then it should pass with "1 tests, 1 assertions, 0 failures, 0 errors"