cypress-on-rails 1.17.0 → 1.18.0

data/lib/cypress_on_rails/version.rb

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

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

@@ -6,6 +6,14 @@ if defined?(CypressOnRails)
     # 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

@@ -47,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

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

data/specs_e2e/rails_6_1/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+# Bundle edge Rails instead: gem 'rails', github: 'rails/rails', branch: 'main'
+gem 'rails', '~> 6.1.7', '>= 6.1.7.10'
+# Use sqlite3 as the database for Active Record
+gem 'sqlite3', '~> 1.4'
+# Use Puma as the app server
+gem 'puma', '~> 5.0'
+
+# Reduces boot times through caching; required in config/boot.rb
+gem 'bootsnap', '>= 1.4.4', require: false
+gem 'concurrent-ruby', '< 1.3.5'
+gem 'date', '~> 3.3.3'
+gem 'timeout', '~> 0.3.2'
+
+group :development, :test do
+  gem 'cypress-on-rails', path: '../../'
+  gem 'database_cleaner'
+end

data/specs_e2e/{rails_5_2 → rails_6_1}/Rakefile

@@ -1,6 +1,6 @@
 # Add your own tasks in files placed in lib/tasks ending in .rake,
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
 
-require_relative 'config/application'
+require_relative "config/application"
 
 Rails.application.load_tasks

data/specs_e2e/rails_6_1/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, or any plugin's
+ * vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/specs_e2e/rails_6_1/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/specs_e2e/{rails_5_2 → rails_6_1}/app/views/layouts/application.html.erb

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <title>Rails52</title>
+    <title>App</title>
     <%= csrf_meta_tags %>
     <%= csp_meta_tag %>
   </head>

data/specs_e2e/rails_6_1/bin/bundle

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+  module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../Gemfile", __dir__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, gemfile)
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_requirement
+    @bundler_requirement ||=
+      env_var_version || cli_arg_version ||
+        bundler_requirement_for(lockfile_version)
+  end
+
+  def bundler_requirement_for(version)
+    return "#{Gem::Requirement.default}.a" unless version
+
+    bundler_gem_version = Gem::Version.new(version)
+
+    requirement = bundler_gem_version.approximate_recommendation
+
+    return requirement unless Gem.rubygems_version < Gem::Version.new("2.7.0")
+
+    requirement += ".a" if bundler_gem_version.prerelease?
+
+    requirement
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    activate_bundler
+  end
+
+  def activate_bundler
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_requirement
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end

data/specs_e2e/rails_6_1/bin/rails

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+load File.expand_path("spring", __dir__)
+APP_PATH = File.expand_path('../config/application', __dir__)
+require_relative "../config/boot"
+require "rails/commands"

data/specs_e2e/rails_6_1/bin/rake

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+load File.expand_path("spring", __dir__)
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

data/specs_e2e/{rails_5_2 → rails_6_1}/bin/setup

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
-require 'fileutils'
-include FileUtils
+require "fileutils"
 
 # path to your application root.
 APP_ROOT = File.expand_path('..', __dir__)
@@ -9,14 +8,26 @@ def system!(*args)
   system(*args) || abort("\n== Command #{args} failed ==")
 end
 
-chdir APP_ROOT do
-  # This script is a starting point to setup your application.
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
   # Add necessary setup steps to this file.
 
   puts '== Installing dependencies =='
   system! 'gem install bundler --conservative'
   system('bundle check') || system!('bundle install')
 
+  # Install JavaScript dependencies
+  system! 'bin/yarn'
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?('config/database.yml')
+  #   FileUtils.cp 'config/database.yml.sample', 'config/database.yml'
+  # end
+
+  puts "\n== Preparing database =="
+  system! 'bin/rails db:prepare'
+
   puts "\n== Removing old logs and tempfiles =="
   system! 'bin/rails log:clear tmp:clear'
 

data/specs_e2e/rails_6_1/bin/spring

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+if !defined?(Spring) && [nil, "development", "test"].include?(ENV["RAILS_ENV"])
+  gem "bundler"
+  require "bundler"
+
+  # Load Spring without loading other gems in the Gemfile, for speed.
+  Bundler.locked_gems&.specs&.find { |spec| spec.name == "spring" }&.tap do |spring|
+    Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
+    gem "spring", spring.version
+    require "spring/binstub"
+  rescue Gem::LoadError
+    # Ignore when Spring is not installed.
+  end
+end

data/specs_e2e/rails_6_1/bin/yarn

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path('..', __dir__)
+Dir.chdir(APP_ROOT) do
+  yarn = ENV["PATH"].split(File::PATH_SEPARATOR).
+    select { |dir| File.expand_path(dir) != __dir__ }.
+    product(["yarn", "yarn.cmd", "yarn.ps1"]).
+    map { |dir, file| File.expand_path(file, dir) }.
+    find { |file| File.executable?(file) }
+
+  if yarn
+    exec yarn, *ARGV
+  else
+    $stderr.puts "Yarn executable was not detected in the system."
+    $stderr.puts "Download Yarn at https://yarnpkg.com/en/docs/install"
+    exit 1
+  end
+end

data/specs_e2e/rails_6_1/config/application.rb

@@ -0,0 +1,34 @@
+require_relative 'boot'
+
+require 'logger'
+require 'rails'
+# Pick the frameworks you want:
+require 'active_model/railtie'
+require 'active_job/railtie'
+require 'active_record/railtie'
+require 'active_storage/engine'
+require 'action_controller/railtie'
+require 'action_text/engine'
+require 'action_view/railtie'
+require 'action_cable/engine'
+# require "sprockets/railtie"
+# require "rails/test_unit/railtie"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module App
+  class Application < Rails::Application
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults 6.1
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+  end
+end

data/specs_e2e/rails_6_1/config/boot.rb

@@ -0,0 +1,4 @@
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+
+require "bundler/setup" # Set up gems listed in the Gemfile.
+require "bootsnap/setup" # Speed up boot time by caching expensive operations.

data/specs_e2e/rails_6_1/config/cable.yml

@@ -0,0 +1,10 @@
+development:
+  adapter: async
+
+test:
+  adapter: test
+
+production:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  channel_prefix: app_production