cypress-on-rails 1.17.0 → 1.19.0

data/lib/cypress_on_rails/server.rb

@@ -0,0 +1,197 @@
+require 'socket'
+require 'timeout'
+require 'fileutils'
+require 'cypress_on_rails/configuration'
+
+module CypressOnRails
+  class Server
+    attr_reader :host, :port, :framework, :install_folder
+
+    def initialize(options = {})
+      config = CypressOnRails.configuration
+      
+      @framework = options[:framework] || :cypress
+      @host = options[:host] || config.server_host
+      @port = options[:port] || config.server_port || find_available_port
+      @port = @port.to_i if @port
+      @install_folder = options[:install_folder] || config.install_folder || detect_install_folder
+      @transactional = options.fetch(:transactional, config.transactional_server)
+    end
+
+    def open
+      start_server do
+        run_command(open_command, "Opening #{framework} test runner")
+      end
+    end
+
+    def run
+      start_server do
+        result = run_command(run_command_args, "Running #{framework} tests")
+        exit(result ? 0 : 1)
+      end
+    end
+
+    def init
+      ensure_install_folder_exists
+      puts "#{framework.to_s.capitalize} configuration initialized at #{install_folder}"
+    end
+
+    private
+
+    def detect_install_folder
+      # Check common locations for cypress/playwright installation
+      possible_folders = ['e2e', 'spec/e2e', 'spec/cypress', 'spec/playwright', 'cypress', 'playwright']
+      folder = possible_folders.find { |f| File.exist?(File.expand_path(f)) }
+      folder || 'e2e'
+    end
+
+    def ensure_install_folder_exists
+      unless File.exist?(install_folder)
+        puts "Creating #{install_folder} directory..."
+        FileUtils.mkdir_p(install_folder)
+      end
+    end
+
+    def find_available_port
+      server = TCPServer.new('127.0.0.1', 0)
+      port = server.addr[1]
+      server.close
+      port
+    end
+
+    def start_server(&block)
+      config = CypressOnRails.configuration
+      
+      run_hook(config.before_server_start)
+      
+      ENV['CYPRESS'] = '1'
+      ENV['RAILS_ENV'] = 'test'
+      
+      server_pid = spawn_server
+      
+      begin
+        wait_for_server
+        run_hook(config.after_server_start)
+        
+        puts "Rails server started on #{base_url}"
+        
+        if @transactional && defined?(ActiveRecord::Base)
+          ActiveRecord::Base.connection.begin_transaction(joinable: false)
+          run_hook(config.after_transaction_start)
+        end
+        
+        yield
+        
+      ensure
+        run_hook(config.before_server_stop)
+        
+        if @transactional && defined?(ActiveRecord::Base)
+          ActiveRecord::Base.connection.rollback_transaction if ActiveRecord::Base.connection.transaction_open?
+        end
+        
+        stop_server(server_pid)
+        ENV.delete('CYPRESS')
+      end
+    end
+
+    def spawn_server
+      rails_args = if File.exist?('bin/rails')
+        ['bin/rails']
+      else
+        ['bundle', 'exec', 'rails']
+      end
+
+      server_args = rails_args + ['server', '-p', port.to_s, '-b', host]
+
+      puts "Starting Rails server: #{server_args.join(' ')}"
+
+      spawn(*server_args, out: $stdout, err: $stderr)
+    end
+
+    def wait_for_server(timeout = 30)
+      Timeout.timeout(timeout) do
+        loop do
+          begin
+            TCPSocket.new(host, port).close
+            break
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            sleep 0.1
+          end
+        end
+      end
+    rescue Timeout::Error
+      raise "Rails server failed to start on #{host}:#{port} after #{timeout} seconds"
+    end
+
+    def stop_server(pid)
+      if pid
+        puts "Stopping Rails server (PID: #{pid})"
+        Process.kill('TERM', pid)
+        Process.wait(pid)
+      end
+    rescue Errno::ESRCH
+      # Process already terminated
+    end
+
+    def base_url
+      "http://#{host}:#{port}"
+    end
+
+    def open_command
+      case framework
+      when :cypress
+        if command_exists?('yarn')
+          ['yarn', 'cypress', 'open', '--project', install_folder, '--config', "baseUrl=#{base_url}"]
+        elsif command_exists?('npx')
+          ['npx', 'cypress', 'open', '--project', install_folder, '--config', "baseUrl=#{base_url}"]
+        else
+          ['cypress', 'open', '--project', install_folder, '--config', "baseUrl=#{base_url}"]
+        end
+      when :playwright
+        if command_exists?('yarn')
+          ['yarn', 'playwright', 'test', '--ui']
+        elsif command_exists?('npx')
+          ['npx', 'playwright', 'test', '--ui']
+        else
+          ['playwright', 'test', '--ui']
+        end
+      end
+    end
+
+    def run_command_args
+      case framework
+      when :cypress
+        if command_exists?('yarn')
+          ['yarn', 'cypress', 'run', '--project', install_folder, '--config', "baseUrl=#{base_url}"]
+        elsif command_exists?('npx')
+          ['npx', 'cypress', 'run', '--project', install_folder, '--config', "baseUrl=#{base_url}"]
+        else
+          ['cypress', 'run', '--project', install_folder, '--config', "baseUrl=#{base_url}"]
+        end
+      when :playwright
+        if command_exists?('yarn')
+          ['yarn', 'playwright', 'test']
+        elsif command_exists?('npx')
+          ['npx', 'playwright', 'test']
+        else
+          ['playwright', 'test']
+        end
+      end
+    end
+
+    def run_command(command_args, description)
+      puts "#{description}: #{command_args.join(' ')}"
+      system(*command_args)
+    end
+
+    def command_exists?(command)
+      system("which #{command} > /dev/null 2>&1")
+    end
+
+    def run_hook(hook)
+      if hook && hook.respond_to?(:call)
+        hook.call
+      end
+    end
+  end
+end

data/lib/cypress_on_rails/state_reset_middleware.rb

@@ -0,0 +1,58 @@
+module CypressOnRails
+  class StateResetMiddleware
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      if env['PATH_INFO'] == '/__cypress__/reset_state' || env['PATH_INFO'] == '/cypress_rails_reset_state'
+        reset_application_state
+        [200, { 'Content-Type' => 'text/plain' }, ['State reset completed']]
+      else
+        @app.call(env)
+      end
+    end
+    
+    private
+    
+    def reset_application_state
+      config = CypressOnRails.configuration
+
+      # Default state reset actions
+      if defined?(DatabaseCleaner)
+        DatabaseCleaner.clean_with(:truncation)
+      elsif defined?(ActiveRecord::Base)
+        connection = ActiveRecord::Base.connection
+
+        # Use disable_referential_integrity if available for safer table clearing
+        if connection.respond_to?(:disable_referential_integrity)
+          connection.disable_referential_integrity do
+            connection.tables.each do |table|
+              next if table == 'schema_migrations' || table == 'ar_internal_metadata'
+              connection.execute("DELETE FROM #{connection.quote_table_name(table)}")
+            end
+          end
+        else
+          # Fallback to regular deletion with proper table name quoting
+          connection.tables.each do |table|
+            next if table == 'schema_migrations' || table == 'ar_internal_metadata'
+            connection.execute("DELETE FROM #{connection.quote_table_name(table)}")
+          end
+        end
+      end
+
+      # Clear Rails cache
+      Rails.cache.clear if defined?(Rails) && Rails.cache
+
+      # Reset any class-level state
+      ActiveSupport::Dependencies.clear if defined?(ActiveSupport::Dependencies)
+
+      # Run after_state_reset hook after cleanup is complete
+      run_hook(config.after_state_reset)
+    end
+    
+    def run_hook(hook)
+      hook.call if hook && hook.respond_to?(:call)
+    end
+  end
+end

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.17.0'.freeze
+  VERSION = '1.19.0'.freeze
 end

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

@@ -6,7 +6,27 @@ 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
+    
+    # Server configuration for rake tasks (cypress:open, cypress:run, playwright:open, playwright:run)
+    # c.server_host = 'localhost'  # or use ENV['CYPRESS_RAILS_HOST']
+    # c.server_port = 3001         # or use ENV['CYPRESS_RAILS_PORT']  
+    # c.transactional_server = true  # Enable automatic transaction rollback between tests
+    
+    # Server lifecycle hooks for rake tasks
+    # c.before_server_start = -> { DatabaseCleaner.clean_with(:truncation) }
+    # c.after_server_start = -> { puts "Test server started on port #{CypressOnRails.configuration.server_port}" }
+    # c.after_transaction_start = -> { Rails.application.load_seed }
+    # c.after_state_reset = -> { Rails.cache.clear }
+    # c.before_server_stop = -> { puts "Stopping test server..." }
 
     # If you want to enable a before_request logic, such as authentication, logging, sending metrics, etc.
     #   Refer to https://www.rubydoc.info/gems/rack/Rack/Request for the `request` argument.

data/lib/generators/cypress_on_rails/templates/spec/cypress/e2e/rails_examples/using_factory_bot.cy.js

@@ -9,7 +9,7 @@ describe('Rails using factory bot examples', function() {
     ])
     cy.visit('/')
     cy.get('table').find('tbody').should(($tbody) => {
-      // clean should of removed these from other tests
+      // clean should have removed these from other tests
       expect($tbody).not.to.contain('Hello World')
 
       expect($tbody).to.contain('Good bye Mars')
@@ -23,7 +23,7 @@ describe('Rails using factory bot examples', function() {
     ])
     cy.visit('/')
     cy.get('table').find('tbody').should(($tbody) => {
-      // clean should of removed these from other tests
+      // clean should have removed these from other tests
       expect($tbody).to.contain('Hello World')
       expect($tbody).not.to.contain('Good bye Mars')
     })

data/lib/generators/cypress_on_rails/templates/spec/cypress/e2e/rails_examples/using_scenarios.cy.js

@@ -7,7 +7,7 @@ describe('Rails using scenarios examples', function() {
     cy.appScenario('basic')
     cy.visit('/')
     cy.get('table').find('tbody').should(($tbody) => {
-      // clean should of removed these from other tests
+      // clean should have removed these from other tests
       expect($tbody).not.to.contain('Good bye Mars')
       expect($tbody).not.to.contain('Hello World')
 

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

@@ -1,4 +1,4 @@
-// CypressOnRails: dont remove these command
+// CypressOnRails: don't remove these commands
 Cypress.Commands.add('appCommands', function (body) {
   Object.keys(body).forEach(key => body[key] === undefined ? delete body[key] : {});
   const log = Cypress.log({ name: "APP", message: body, autoEnd: false })
@@ -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/lib/tasks/cypress.rake

@@ -0,0 +1,33 @@
+namespace :cypress do
+  desc "Open Cypress test runner UI"
+  task :open => :environment do
+    require 'cypress_on_rails/server'
+    CypressOnRails::Server.new.open
+  end
+
+  desc "Run Cypress tests in headless mode"
+  task :run => :environment do
+    require 'cypress_on_rails/server'
+    CypressOnRails::Server.new.run
+  end
+
+  desc "Initialize Cypress configuration"
+  task :init => :environment do
+    require 'cypress_on_rails/server'
+    CypressOnRails::Server.new.init
+  end
+end
+
+namespace :playwright do
+  desc "Open Playwright test runner UI"
+  task :open => :environment do
+    require 'cypress_on_rails/server'
+    CypressOnRails::Server.new(framework: :playwright).open
+  end
+
+  desc "Run Playwright tests in headless mode"
+  task :run => :environment do
+    require 'cypress_on_rails/server'
+    CypressOnRails::Server.new(framework: :playwright).run
+  end
+end

data/rakelib/release.rake

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "bundler"
+require_relative "task_helpers"
+
+class RaisingMessageHandler
+  def add_error(error)
+    raise error
+  end
+end
+
+# rubocop:disable Metrics/BlockLength
+
+desc("Releases the gem using the given version.
+
+IMPORTANT: the gem version must be in valid rubygem format (no dashes).
+
+This task depends on the gem-release (ruby gem) which is installed via `bundle install`
+
+1st argument: The new version in rubygem format (no dashes). Pass no argument to
+              automatically perform a patch version bump.
+2nd argument: Perform a dry run by passing 'true' as a second argument.
+
+Note, accept defaults for rubygems options. Script will pause to get 2FA tokens.
+
+Example: `rake release[2.1.0,false]`")
+task :release, %i[gem_version dry_run] do |_t, args|
+  include CypressOnRails::TaskHelpers
+
+  # Check if there are uncommitted changes
+  unless `git status --porcelain`.strip.empty?
+    raise "You have uncommitted changes. Please commit or stash them before releasing."
+  end
+
+  args_hash = args.to_hash
+
+  is_dry_run = args_hash[:dry_run] == 'true'
+
+  gem_version = args_hash.fetch(:gem_version, "")
+
+  # See https://github.com/svenfuchs/gem-release
+  sh_in_dir(gem_root, "git pull --rebase")
+  sh_in_dir(gem_root, "gem bump --no-commit --file lib/cypress_on_rails/version.rb #{gem_version.strip.empty? ? '' : %(--version #{gem_version})}")
+
+  # Read the actual version from the file after bump
+  load File.expand_path("../lib/cypress_on_rails/version.rb", __dir__)
+  actual_version = CypressOnRails::VERSION
+
+  # Update Gemfile.lock files
+  sh_in_dir(gem_root, "bundle install")
+
+  unless is_dry_run
+    # Commit the version bump
+    sh_in_dir(gem_root, "git add lib/cypress_on_rails/version.rb")
+    sh_in_dir(gem_root, "git commit -m \"Release v#{actual_version}\"")
+
+    # Tag the release
+    sh_in_dir(gem_root, "git tag v#{actual_version}")
+
+    # Push the commit and tag
+    sh_in_dir(gem_root, "git push && git push --tags")
+
+    # Release the new gem version
+    puts "Carefully add your OTP for Rubygems. If you get an error, run 'gem release' again."
+    sh_in_dir(gem_root, "gem release")
+  else
+    puts "DRY RUN: Would have committed, tagged v#{actual_version}, pushed, and released gem"
+  end
+
+  msg = <<~MSG
+    Once you have successfully published, run these commands to update CHANGELOG.md:
+
+    bundle exec rake update_changelog
+    git commit -a -m 'Update CHANGELOG.md'
+    git push
+  MSG
+  puts msg
+end
+
+# rubocop:enable Metrics/BlockLength