cypress-on-rails 1.16.0 → 1.18.0

data/lib/cypress_on_rails/vcr/insert_eject_middleware.rb

@@ -0,0 +1,75 @@
+require_relative 'middleware_helpers'
+
+module CypressOnRails
+  module Vcr
+    # Middleware to handle vcr with insert/eject endpoints
+    class InsertEjectMiddleware
+      include MiddlewareHelpers
+
+      def initialize(app, vcr = nil)
+        @app = app
+        @vcr = vcr
+        @first_call = false
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        if request.path.start_with?('/__e2e__/vcr/insert')
+          configuration.tagged_logged { handle_insert(request) }
+        elsif request.path.start_with?('/__e2e__/vcr/eject')
+          configuration.tagged_logged { handle_eject }
+        else
+          do_first_call unless @first_call
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def handle_insert(req)
+        WebMock.enable! if defined?(WebMock)
+        vcr.turn_on!
+        body = parse_request_body(req)
+        logger.info "vcr insert cassette: #{body}"
+        cassette_name, options = extract_cassette_info(body)
+        vcr.insert_cassette(cassette_name, options)
+        [201, { 'Content-Type' => 'application/json' }, [{ 'message': 'OK' }.to_json]]
+      rescue JSON::ParserError => e
+        [400, { 'Content-Type' => 'application/json' }, [{ 'message': e.message }.to_json]]
+      rescue LoadError, ArgumentError => e
+        [500, { 'Content-Type' => 'application/json' }, [{ 'message': e.message }.to_json]]
+      end
+
+      def parse_request_body(req)
+        JSON.parse(req.body.read)
+      end
+
+      def extract_cassette_info(body)
+        cassette_name = body[0]
+        options = (body[1] || {}).symbolize_keys
+        options[:record] = options[:record].to_sym if options[:record]
+        options[:match_requests_on] = options[:match_requests_on].map(&:to_sym) if options[:match_requests_on]
+        options[:serialize_with] = options[:serialize_with].to_sym if options[:serialize_with]
+        options[:persist_with] = options[:persist_with].to_sym if options[:persist_with]
+        [cassette_name, options]
+      end
+
+      def handle_eject
+        logger.info 'vcr eject cassette'
+        vcr.eject_cassette
+        do_first_call
+        [201, { 'Content-Type' => 'application/json' }, [{ 'message': 'OK' }.to_json]]
+      rescue LoadError, ArgumentError => e
+        [500, { 'Content-Type' => 'application/json' }, [{ 'message': e.message }.to_json]]
+      end
+
+      def do_first_call
+        @first_call = true
+        vcr.turn_off!
+        WebMock.disable! if defined?(WebMock)
+      rescue LoadError
+        # nop
+      end
+    end
+  end
+end

data/lib/cypress_on_rails/vcr/middleware_helpers.rb

@@ -0,0 +1,51 @@
+require 'cypress_on_rails/middleware_config'
+
+module CypressOnRails
+  module Vcr
+    # Provides helper methods for VCR middlewares
+    module MiddlewareHelpers
+      include MiddlewareConfig
+
+      def vcr
+        @vcr ||= configure_vcr
+      end
+
+      def cassette_library_dir
+        configuration.vcr_options&.fetch(:cassette_library_dir) do
+          "#{configuration.install_folder}/fixtures/vcr_cassettes"
+        end
+      end
+
+      private
+
+      def configure_vcr
+        require 'vcr'
+        VCR.configure do |config|
+          config.cassette_library_dir = cassette_library_dir
+          apply_vcr_options(config) if configuration.vcr_options.present?
+        end
+        VCR
+      end
+
+      def apply_vcr_options(config)
+        configuration.vcr_options.each do |option, value|
+          next if option.to_sym == :cassette_library_dir
+
+          apply_vcr_option(config, option, value)
+        end
+      end
+
+      def apply_vcr_option(config, option, value)
+        return unless config.respond_to?(option) || config.respond_to?("#{option}=")
+
+        if config.respond_to?("#{option}=")
+          config.send("#{option}=", value)
+        elsif value.is_a?(Array)
+          config.send(option, *value)
+        else
+          config.send(option, value)
+        end
+      end
+    end
+  end
+end

data/lib/cypress_on_rails/vcr/use_cassette_middleware.rb

@@ -0,0 +1,56 @@
+require_relative 'middleware_helpers'
+
+module CypressOnRails
+  module Vcr
+    # Middleware to handle vcr with use_cassette
+    class UseCassetteMiddleware
+      include MiddlewareHelpers
+
+      def initialize(app, vcr = nil)
+        @app = app
+        @vcr = vcr
+      end
+
+      def call(env)
+        return @app.call(env) if should_not_use_vcr?
+
+        initialize_vcr
+        handle_request_with_vcr(env)
+      end
+
+      private
+
+      def vcr_defined?
+        defined?(VCR) != nil
+      end
+
+      def should_not_use_vcr?
+        vcr_defined? &&
+          VCR.configuration.cassette_library_dir.present? &&
+          VCR.configuration.cassette_library_dir != cassette_library_dir
+      end
+
+      def initialize_vcr
+        WebMock.enable! if defined?(WebMock)
+        vcr.turn_on!
+      end
+
+      def handle_request_with_vcr(env)
+        request = Rack::Request.new(env)
+        cassette_name = fetch_request_cassette(request)
+        vcr.use_cassette(cassette_name) do
+          logger.info "Handle request with cassette name: #{cassette_name}"
+          @app.call(env)
+        end
+      end
+
+      def fetch_request_cassette(request)
+        if request.path.start_with?('/graphql') && request.params.key?('operation')
+          "#{request.path}/#{request.params['operation']}"
+        else
+          request.path
+        end
+      end
+    end
+  end
+end

data/lib/cypress_on_rails/version.rb

@@ -1,3 +1,3 @@
 module CypressOnRails
-  VERSION = '1.16.0'.freeze
+  VERSION = '1.18.0'.freeze
 end

data/lib/generators/cypress_on_rails/install_generator.rb

@@ -1,12 +1,9 @@
 module CypressOnRails
   class InstallGenerator < Rails::Generators::Base
     class_option :api_prefix, type: :string, default: ''
+    class_option :framework, type: :string, default: 'cypress'
     class_option :install_folder, type: :string, default: 'e2e'
-    class_option :install_cypress, type: :boolean, default: true
-    class_option :install_playwright, type: :boolean, default: false
     class_option :install_with, type: :string, default: 'yarn'
-    class_option :cypress_folder, type: :string, default: 'cypress'
-    class_option :playwright_folder, type: :string, default: 'playwright'
     class_option :experimental, type: :boolean, default: false
     source_root File.expand_path('../templates', __FILE__)
 
@@ -17,10 +14,11 @@ module CypressOnRails
 
       command = nil
       packages = []
-
-      packages << 'cypress' if options.install_cypress
-      packages.push('playwright', '@playwright/test') if options.install_playwright
-
+      packages = if options.framework == 'cypress'
+                   ['cypress', 'cypress-on-rails']
+                 elsif options.framework == 'playwright'
+                   ['playwright', '@playwright/test']
+                 end
       if options.install_with == 'yarn'
         command = "yarn --cwd=#{install_dir} add #{packages.join(' ')} --dev"
       elsif options.install_with == 'npm'
@@ -31,38 +29,42 @@ module CypressOnRails
         fail "failed to install #{packages.join(' ')}" unless system(command)
       end
 
-      if options.install_cypress
-        template "spec/cypress/support/index.js.erb", "#{options.cypress_folder}/support/index.js"
-        copy_file "spec/cypress/support/commands.js", "#{options.cypress_folder}/support/commands.js"
-        copy_file "spec/cypress.config.js", "#{options.cypress_folder}/../cypress.config.js"
+      if options.framework == 'cypress'
+        template "spec/cypress/support/index.js.erb", "#{options.install_folder}/cypress/support/index.js"
+        copy_file "spec/cypress/support/commands.js", "#{options.install_folder}/cypress/support/commands.js"
+        copy_file "spec/cypress.config.js", "#{options.install_folder}/cypress.config.js"
       end
-      if options.install_playwright
-        template "spec/playwright/support/index.js.erb", "#{options.playwright_folder}/support/index.js"
-        copy_file "spec/playwright.config.js", "#{options.playwright_folder}/../playwright.config.js"
+      if options.framework == 'playwright'
+        template "spec/playwright/support/index.js.erb", "#{options.install_folder}/playwright/support/index.js"
+        copy_file "spec/playwright.config.js", "#{options.install_folder}/playwright.config.js"
       end
     end
 
     def add_initial_files
       template "config/initializers/cypress_on_rails.rb.erb", "config/initializers/cypress_on_rails.rb"
-      template "spec/e2e/e2e_helper.rb.erb", "#{options.install_folder}/e2e_helper.rb"
-      directory 'spec/e2e/app_commands', "#{options.install_folder}/app_commands"
-      if options.install_cypress
-        copy_file "spec/cypress/support/on-rails.js", "#{options.cypress_folder}/support/on-rails.js"
-        directory 'spec/cypress/e2e/rails_examples', "#{options.cypress_folder}/e2e/rails_examples"
+      template "spec/e2e/e2e_helper.rb.erb", "#{options.install_folder}/#{options.framework}/e2e_helper.rb"
+      directory 'spec/e2e/app_commands', "#{options.install_folder}/#{options.framework}/app_commands"
+      if options.framework == 'cypress'
+        copy_file "spec/cypress/support/on-rails.js", "#{options.install_folder}/cypress/support/on-rails.js"
+        directory 'spec/cypress/e2e/rails_examples', "#{options.install_folder}/cypress/e2e/rails_examples"
       end
-      if options.install_playwright
-        copy_file "spec/playwright/support/on-rails.js", "#{options.playwright_folder}/support/on-rails.js"
-        directory 'spec/playwright/e2e/rails_examples', "#{options.playwright_folder}/e2e/rails_examples"
+      if options.framework == 'playwright'
+        copy_file "spec/playwright/support/on-rails.js", "#{options.install_folder}/playwright/support/on-rails.js"
+        directory 'spec/playwright/e2e/rails_examples', "#{options.install_folder}/playwright/e2e/rails_examples"
       end
     end
 
     def update_files
-      append_to_file "#{options.cypress_folder}/support/index.js",
-                     "\nimport './on-rails'",
-                     after: 'import \'./commands\''
-      append_to_file "#{options.playwright_folder}/support/index.js",
-                     "\nimport './on-rails'",
-                     after: '// Import commands.js using ES2015 syntax:'
+      if options.framework == 'cypress'
+        append_to_file "#{options.install_folder}/cypress/support/index.js",
+                       "\nimport './on-rails'",
+                       after: 'import \'./commands\''
+      end
+      if options.framework == 'playwright'
+        append_to_file "#{options.install_folder}/playwright/support/index.js",
+                       "\nimport './on-rails'",
+                       after: '// Import commands.js using ES2015 syntax:'
+      end
     end
   end
 end

data/lib/generators/cypress_on_rails/templates/config/initializers/cypress_on_rails.rb.erb

@@ -1,11 +1,19 @@
 if defined?(CypressOnRails)
   CypressOnRails.configure do |c|
     c.api_prefix = "<%= options.api_prefix %>"
-    c.install_folder = File.expand_path("#{__dir__}/../../<%= options.install_folder %>")
+    c.install_folder = File.expand_path("#{__dir__}/../../<%= options.install_folder %>/<%= options.framework %>")
     # WARNING!! CypressOnRails can execute arbitrary ruby code
     # please use with extra caution if enabling on hosted servers or starting your local server on 0.0.0.0
     c.use_middleware = !Rails.env.production?
     <% unless options.experimental %># <% end %> c.use_vcr_middleware = !Rails.env.production?
+    <% unless options.experimental %># <% end %> # Use this if you want to use use_cassette wrapper instead of manual insert/eject
+    <% unless options.experimental %># <% end %> # c.use_vcr_use_cassette_middleware = !Rails.env.production?
+    <% unless options.experimental %># <% end %> # Pass custom VCR options
+    <% unless options.experimental %># <% end %> c.vcr_options = {
+    <% unless options.experimental %># <% end %>   hook_into: :webmock,
+    <% unless options.experimental %># <% end %>   default_cassette_options: { record: :once },
+    <% unless options.experimental %># <% end %>   cassette_library_dir: File.expand_path("#{__dir__}/../../<%= options.install_folder %>/<%= options.framework %>/fixtures/vcr_cassettes")
+    <% unless options.experimental %># <% end %> }
     c.logger = Rails.logger
 
     # If you want to enable a before_request logic, such as authentication, logging, sending metrics, etc.

data/lib/generators/cypress_on_rails/templates/spec/cypress/support/commands.js

@@ -23,3 +23,25 @@
 //
 // -- This is will overwrite an existing command --
 // Cypress.Commands.overwrite("visit", (originalFn, url, options) => { ... })
+//
+//
+// -- This is for Graphql usage. Add proxy-like mock to add operation name into query string --
+// Cypress.Commands.add('mockGraphQL', () => {
+//   cy.on('window:before:load', (win) => {
+//     const originalFetch = win.fetch;
+//     const fetch = (path, options, ...rest) => {
+//       if (options && options.body) {
+//         try {
+//           const body = JSON.parse(options.body);
+//           if (body.operationName) {
+//             return originalFetch(`${path}?operation=${body.operationName}`, options, ...rest);
+//           }
+//         } catch (e) {
+//           return originalFetch(path, options, ...rest);
+//         }
+//       }
+//       return originalFetch(path, options, ...rest);
+//     };
+//     cy.stub(win, 'fetch', fetch);
+//   });
+// });

data/lib/generators/cypress_on_rails/templates/spec/cypress/support/on-rails.js

@@ -6,6 +6,9 @@ Cypress.Commands.add('appCommands', function (body) {
     method: 'POST',
     url: "/__e2e__/command",
     body: JSON.stringify(body),
+    headers: {
+      'Content-Type': 'application/json',
+    },
     log: false,
     failOnStatusCode: false
   }).then((response) => {
@@ -44,6 +47,7 @@ Cypress.Commands.add('appFixtures', function (options) {
 // The next is optional
 // beforeEach(() => {
 //  cy.app('clean') // have a look at cypress/app_commands/clean.rb
+//  cy.mockGraphQL() // for GraphQL usage with use_cassette, see cypress/support/commands.rb
 // });
 
 // comment this out if you do not want to attempt to log additional info on test fail
@@ -52,6 +56,9 @@ Cypress.on('fail', (err, runnable) => {
   Cypress.$.ajax({
     url: '/__e2e__/command',
     data: JSON.stringify({name: 'log_fail', options: {error_message: err.message, runnable_full_title: runnable.fullTitle() }}),
+    headers: {
+      'Content-Type': 'application/json',
+    },
     async: false,
     method: 'POST'
   });

data/lib/generators/cypress_on_rails/templates/spec/e2e/e2e_helper.rb.erb

@@ -36,8 +36,3 @@ CypressOnRails::SmartFactoryWrapper.configure(
       Rails.root.join('spec', 'factories', '**', '*.rb')
     ]
 )
-
-<% unless options.experimental %># <% end %>require 'vcr'
-<% unless options.experimental %># <% end %>VCR.configure do |config|
-<% unless options.experimental %># <% end %>  config.hook_into :webmock
-<% unless options.experimental %># <% end %>end

data/spec/cypress_on_rails/configuration_spec.rb

@@ -9,22 +9,25 @@ RSpec.describe CypressOnRails::Configuration do
     expect(CypressOnRails.configuration.use_middleware?).to eq(true)
     expect(CypressOnRails.configuration.logger).to_not be_nil
     expect(CypressOnRails.configuration.before_request).to_not be_nil
+    expect(CypressOnRails.configuration.vcr_options).to eq({})
   end
 
   it 'can be configured' do
     my_logger = Logger.new(STDOUT)
-    before_request_lambda = -> (_) { return [200, {}, ['hello world']] }
+    before_request_lambda = ->(_) { return [200, {}, ['hello world']] }
     CypressOnRails.configure do |config|
       config.api_prefix = '/api'
       config.install_folder = 'my/path'
       config.use_middleware = false
       config.logger = my_logger
       config.before_request = before_request_lambda
+      config.vcr_options = { hook_into: :webmock }
     end
     expect(CypressOnRails.configuration.api_prefix).to eq('/api')
     expect(CypressOnRails.configuration.install_folder).to eq('my/path')
     expect(CypressOnRails.configuration.use_middleware?).to eq(false)
     expect(CypressOnRails.configuration.logger).to eq(my_logger)
     expect(CypressOnRails.configuration.before_request).to eq(before_request_lambda)
+    expect(CypressOnRails.configuration.vcr_options).to eq(hook_into: :webmock)
   end
 end

data/spec/cypress_on_rails/vcr/insert_eject_middleware_spec.rb

@@ -0,0 +1,177 @@
+require 'cypress_on_rails/vcr/insert_eject_middleware'
+require 'vcr'
+require 'active_support/core_ext/hash' unless {}.respond_to?(:symbolize_keys)
+
+module CypressOnRails
+  module Vcr
+    RSpec.describe InsertEjectMiddleware do
+      let(:app) { ->(env) { [200, {}, ["app did #{env['PATH_INFO']}"]] } }
+      let(:vcr) { class_double(VCR, turn_on!: true, turn_off!: true, insert_cassette: true, eject_cassette: true) }
+      subject { described_class.new(app, vcr) }
+
+      let(:env) { {} }
+
+      let(:response) { subject.call(env) }
+
+      def rack_input(json_value)
+        StringIO.new(JSON.generate(json_value))
+      end
+
+      describe '/__e2e__/vcr/insert' do
+        before do
+          env['PATH_INFO'] = '/__e2e__/vcr/insert'
+        end
+
+        it do
+          env['rack.input'] = rack_input(['cas1'])
+
+          aggregate_failures do
+            expect(response).to eq([201,
+                                    { 'Content-Type' => 'application/json' },
+                                    ['{"message":"OK"}']])
+            expect(vcr).to have_received(:turn_on!)
+            expect(vcr).to have_received(:insert_cassette).with('cas1', {})
+          end
+        end
+
+        it 'works with record' do
+          env['rack.input'] = rack_input(['cas1', { 'record' => 'new_episodes' }])
+
+          aggregate_failures do
+            expect(response).to eq([201,
+                                    { 'Content-Type' => 'application/json' },
+                                    ['{"message":"OK"}']])
+            expect(vcr).to have_received(:insert_cassette).with('cas1', record: :new_episodes)
+          end
+        end
+
+        it 'works with match_requests_on' do
+          env['rack.input'] = rack_input(['cas1', { 'match_requests_on' => %w[method uri] }])
+
+          aggregate_failures do
+            expect(response).to eq([201,
+                                    { 'Content-Type' => 'application/json' },
+                                    ['{"message":"OK"}']])
+            expect(vcr).to have_received(:insert_cassette).with('cas1', match_requests_on: %i[method uri])
+          end
+        end
+
+        it 'works with serialize_with' do
+          env['rack.input'] = rack_input(['cas1', { 'serialize_with' => 'yaml' }])
+
+          aggregate_failures do
+            expect(response).to eq([201,
+                                    { 'Content-Type' => 'application/json' },
+                                    ['{"message":"OK"}']])
+            expect(vcr).to have_received(:insert_cassette).with('cas1', serialize_with: :yaml)
+          end
+        end
+
+        it 'works with persist_with' do
+          env['rack.input'] = rack_input(['cas1', { 'persist_with' => 'file_system' }])
+
+          aggregate_failures do
+            expect(response).to eq([201,
+                                    { 'Content-Type' => 'application/json' },
+                                    ['{"message":"OK"}']])
+            expect(vcr).to have_received(:insert_cassette).with('cas1', persist_with: :file_system)
+          end
+        end
+
+        context 'when an error occurs' do
+          it 'returns a 500 error with the error message' do
+            env['rack.input'] = rack_input(['cas1'])
+            allow(vcr).to receive(:insert_cassette).and_raise(ArgumentError.new('Invalid cassette name'))
+
+            expect(response).to eq([
+                                     500,
+                                     { 'Content-Type' => 'application/json' },
+                                     ['{"message":"Invalid cassette name"}']
+                                   ])
+          end
+
+          it 'returns a 500 error when LoadError occurs' do
+            env['rack.input'] = rack_input(['cas1'])
+            allow(vcr).to receive(:insert_cassette).and_raise(LoadError.new('Cannot load VCR'))
+
+            expect(response).to eq([
+                                     500,
+                                     { 'Content-Type' => 'application/json' },
+                                     ['{"message":"Cannot load VCR"}']
+                                   ])
+          end
+        end
+
+        it 'returns a 400 error when JSON parsing fails' do
+          env['rack.input'] = StringIO.new('invalid json')
+
+          expect(response).to eq([
+                                   400,
+                                   { 'Content-Type' => 'application/json' },
+                                   ['{"message":"unexpected token at \'invalid json\'"}']
+                                 ])
+        end
+      end
+
+      describe '/__e2e__/vcr/eject' do
+        before do
+          env['PATH_INFO'] = '/__e2e__/vcr/eject'
+        end
+
+        it do
+          aggregate_failures do
+            expect(response).to eq([201,
+                                    { 'Content-Type' => 'application/json' },
+                                    ['{"message":"OK"}']])
+            expect(vcr).to have_received(:turn_off!)
+            expect(vcr).to have_received(:eject_cassette)
+          end
+        end
+
+        context 'when an error occurs' do
+          it 'returns a 500 error with the error message' do
+            allow(vcr).to receive(:eject_cassette).and_raise(ArgumentError.new('No cassette to eject'))
+
+            expect(response).to eq([
+                                     500,
+                                     { 'Content-Type' => 'application/json' },
+                                     ['{"message":"No cassette to eject"}']
+                                   ])
+          end
+
+          it 'returns a 500 error when LoadError occurs' do
+            allow(vcr).to receive(:eject_cassette).and_raise(LoadError.new('Cannot load VCR'))
+
+            expect(response).to eq([
+                                     500,
+                                     { 'Content-Type' => 'application/json' },
+                                     ['{"message":"Cannot load VCR"}']
+                                   ])
+          end
+        end
+      end
+
+      describe '"Other paths"' do
+        it 'calls vcr turn off the first time' do
+          env['PATH_INFO'] = '/test'
+
+          expect(response).to eq([200, {}, ['app did /test']])
+          expect(vcr).to have_received(:turn_off!)
+        end
+
+        it 'runs app' do
+          aggregate_failures do
+            %w[/ /__e2e__/login command /e2e_command /].each do |path|
+              env['PATH_INFO'] = path
+
+              response = subject.call(env)
+
+              expect(response).to eq([200, {}, ["app did #{path}"]])
+              expect(vcr).to have_received(:turn_off!)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cypress_on_rails/vcr/use_cassette_middleware_spec.rb

@@ -0,0 +1,68 @@
+require 'cypress_on_rails/vcr/use_cassette_middleware'
+require 'vcr'
+require 'active_support/core_ext/hash' unless {}.respond_to?(:symbolize_keys)
+
+module CypressOnRails
+  module Vcr
+    RSpec.describe UseCassetteMiddleware do
+      let(:app) { ->(env) { [200, {}, ["app did #{env['PATH_INFO']}"]] } }
+      let(:vcr) { VCR }
+      subject { described_class.new(app, vcr) }
+
+      let(:env) { { 'rack.input' => rack_input([]) } }
+
+      let(:response) { subject.call(env) }
+
+      def rack_input(json_value)
+        StringIO.new(JSON.generate(json_value))
+      end
+
+      before do
+        allow(vcr).to receive(:use_cassette).and_yield
+      end
+
+      it 'returns the application response using correct graphql cassette' do
+        env['PATH_INFO'] = '/graphql'
+        env['QUERY_STRING'] = 'operation=test'
+
+        expect(response).to eq([200, {}, ['app did /graphql']])
+        expect(vcr).to have_received(:use_cassette).with('/graphql/test')
+      end
+
+      it 'returns the application response using default request path cassette' do
+        allow(CypressOnRails).to receive(:configuration).and_return(double(logger: Logger.new(nil)))
+        env['PATH_INFO'] = '/test/path'
+
+        expect(response).to eq([200, {}, ['app did /test/path']])
+        expect(vcr).to have_received(:use_cassette).with('/test/path')
+      end
+
+      context 'when VCR cassette library directory does not match' do
+        before do
+          allow(VCR.configuration).to receive(:cassette_library_dir).and_return('/different/path')
+        end
+
+        it 'returns the application response without using VCR' do
+          env['PATH_INFO'] = '/test/path'
+
+          expect(response).to eq([200, {}, ['app did /test/path']])
+          expect(vcr).not_to have_received(:use_cassette)
+        end
+      end
+
+      context 'when VCR is not defined' do
+        before do
+          allow(subject).to receive(:vcr_defined?).and_return(false)
+        end
+
+        it 'returns the application response without error' do
+          env['PATH_INFO'] = '/graphql'
+          env['QUERY_STRING'] = 'operation=test'
+
+          expect(response).to eq([200, {}, ['app did /graphql']])
+          expect(vcr).to have_received(:use_cassette).with('/graphql/test')
+        end
+      end
+    end
+  end
+end

data/specs_e2e/rails_6_1/.gitattributes

@@ -0,0 +1,10 @@
+# See https://git-scm.com/docs/gitattributes for more about git attribute files.
+
+# Mark the database schema as having been generated.
+db/schema.rb linguist-generated
+
+# Mark the yarn lockfile as having been generated.
+yarn.lock linguist-generated
+
+# Mark any vendored files as having been vendored.
+vendor/* linguist-vendored