cypress-on-rails 1.18.0 → 1.20.0

data/lib/cypress_on_rails/server.rb

@@ -0,0 +1,258 @@
+require 'socket'
+require 'timeout'
+require 'fileutils'
+require 'net/http'
+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)
+      # Process management: track PID and process group for proper cleanup
+      @server_pid = nil
+      @server_pgid = nil
+    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(' ')}"
+
+      @server_pid = spawn(*server_args, out: $stdout, err: $stderr, pgroup: true)
+      begin
+        @server_pgid = Process.getpgid(@server_pid)
+      rescue Errno::ESRCH => e
+        # Edge case: process terminated before we could get pgid
+        # This is OK - send_term_signal will fall back to single-process kill
+        CypressOnRails.configuration.logger.warn("Process #{@server_pid} terminated immediately after spawn: #{e.message}")
+        @server_pgid = nil
+      end
+      @server_pid
+    end
+
+    def wait_for_server(timeout = 30)
+      Timeout.timeout(timeout) do
+        loop do
+          break if server_responding?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      raise "Rails server failed to start on #{host}:#{port} after #{timeout} seconds"
+    end
+
+    def server_responding?
+      config = CypressOnRails.configuration
+      readiness_path = config.server_readiness_path || '/'
+      timeout = config.server_readiness_timeout || 5
+      uri = URI("http://#{host}:#{port}#{readiness_path}")
+
+      response = Net::HTTP.start(uri.host, uri.port, open_timeout: timeout, read_timeout: timeout) do |http|
+        http.get(uri.path)
+      end
+
+      # Accept 200-399 (success and redirects), reject 404 and 5xx
+      # 3xx redirects are considered "ready" because the server is responding correctly
+      (200..399).cover?(response.code.to_i)
+    rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, Errno::ETIMEDOUT, SocketError,
+           Net::OpenTimeout, Net::ReadTimeout, Net::HTTPBadResponse
+      false
+    end
+
+    def stop_server(pid)
+      return unless pid
+
+      puts "Stopping Rails server (PID: #{pid})"
+      send_term_signal(pid)
+
+      begin
+        Timeout.timeout(10) do
+          Process.wait(pid)
+        end
+      rescue Timeout::Error
+        CypressOnRails.configuration.logger.warn("Server did not terminate after TERM signal, sending KILL")
+        safe_kill_process('KILL', pid)
+        Process.wait(pid) rescue Errno::ESRCH
+      end
+    rescue Errno::ESRCH
+      # Process already terminated
+    end
+
+    def send_term_signal(pid)
+      if @server_pgid && process_exists?(pid)
+        Process.kill('TERM', -@server_pgid)
+      else
+        safe_kill_process('TERM', pid)
+      end
+    rescue Errno::ESRCH, Errno::EPERM => e
+      CypressOnRails.configuration.logger.warn("Failed to kill process group #{@server_pgid}: #{e.message}, trying single process")
+      safe_kill_process('TERM', pid)
+    end
+
+    def process_exists?(pid)
+      return false unless pid
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    def safe_kill_process(signal, pid)
+      Process.kill(signal, pid) if pid
+    rescue Errno::ESRCH, Errno::EPERM
+      # Process already terminated or permission denied
+    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/version.rb

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

data/lib/generators/cypress_on_rails/install_generator.rb

@@ -42,8 +42,8 @@ module CypressOnRails
 
     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}/#{options.framework}/e2e_helper.rb"
-      directory 'spec/e2e/app_commands', "#{options.install_folder}/#{options.framework}/app_commands"
+      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.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"

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

@@ -1,7 +1,7 @@
 if defined?(CypressOnRails)
   CypressOnRails.configure do |c|
     c.api_prefix = "<%= options.api_prefix %>"
-    c.install_folder = File.expand_path("#{__dir__}/../../<%= options.install_folder %>/<%= options.framework %>")
+    c.install_folder = File.expand_path("#{__dir__}/../../<%= options.install_folder %>")
     # 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?
@@ -12,9 +12,21 @@ if defined?(CypressOnRails)
     <% 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 %>   cassette_library_dir: File.expand_path("#{__dir__}/../../<%= options.install_folder %>/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/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 })

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

data/rakelib/task_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CypressOnRails
+  module TaskHelpers
+    # Returns the root folder of the cypress-on-rails gem
+    def gem_root
+      File.expand_path("..", __dir__)
+    end
+
+    # Executes a string or an array of strings in a shell in the given directory
+    def sh_in_dir(dir, *shell_commands)
+      Dir.chdir(dir) do
+        # Without `with_unbundled_env`, running bundle in the child directories won't correctly
+        # update the Gemfile.lock
+        Bundler.with_unbundled_env do
+          shell_commands.flatten.each do |shell_command|
+            sh(shell_command.strip)
+          end
+        end
+      end
+    end
+  end
+end

data/rakelib/update_changelog.rake

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "English"
+
+desc "Updates CHANGELOG.md inserting headers for the new version.
+
+Argument: Git tag. Defaults to the latest tag."
+
+task :update_changelog, %i[tag] do |_, args|
+  tag = args[:tag] || `git describe --tags --abbrev=0`.strip
+
+  # Remove 'v' prefix if present (e.g., v1.18.0 -> 1.18.0)
+  version = tag.start_with?('v') ? tag[1..-1] : tag
+  anchor = "[#{version}]"
+
+  changelog = File.read("CHANGELOG.md")
+
+  if changelog.include?(anchor)
+    puts "Tag #{version} is already documented in CHANGELOG.md, update manually if needed"
+    next
+  end
+
+  tag_date_output = `git show -s --format=%cs #{tag} 2>&1`
+  if $CHILD_STATUS.success?
+    tag_date = tag_date_output.split("\n").last.strip
+  else
+    abort("Failed to find tag #{tag}")
+  end
+
+  # After "## [Unreleased]", insert new version header
+  unreleased_section = "## [Unreleased]"
+  new_version_header = "\n\n## #{anchor} - #{tag_date}"
+
+  if changelog.include?(unreleased_section)
+    changelog.sub!(unreleased_section, "#{unreleased_section}#{new_version_header}")
+  else
+    abort("Could not find '## [Unreleased]' section in CHANGELOG.md")
+  end
+
+  # Find and update version comparison links at the bottom
+  # Pattern: [1.18.0]: https://github.com/shakacode/cypress-playwright-on-rails/compare/v1.17.0...v1.18.0
+  compare_link_prefix = "https://github.com/shakacode/cypress-playwright-on-rails/compare"
+
+  # Find the last version link to determine the previous version
+  last_version_match = changelog.match(/\[(\d+\.\d+\.\d+(?:\.\w+)?)\]:.*?compare\/v(\d+\.\d+\.\d+(?:\.\w+)?)\.\.\.v(\d+\.\d+\.\d+(?:\.\w+)?)/)
+
+  if last_version_match
+    last_version = last_version_match[1]
+    # Add new version link at the top of the version list
+    new_link = "#{anchor}: #{compare_link_prefix}/v#{last_version}...v#{version}"
+    # Insert after the "<!-- Version diff reference list -->" comment
+    changelog.sub!("<!-- Version diff reference list -->", "<!-- Version diff reference list -->\n#{new_link}")
+  else
+    puts "Warning: Could not find version comparison links. You may need to add the link manually."
+  end
+
+  File.write("CHANGELOG.md", changelog)
+  puts "Updated CHANGELOG.md with an entry for #{version}"
+  puts "\nNext steps:"
+  puts "1. Edit CHANGELOG.md to add release notes under the [#{version}] section"
+  puts "2. Move content from [Unreleased] to [#{version}] if applicable"
+  puts "3. Review and commit the changes"
+end

data/spec/cypress_on_rails/configuration_spec.rb

@@ -10,6 +10,8 @@ RSpec.describe CypressOnRails::Configuration do
     expect(CypressOnRails.configuration.logger).to_not be_nil
     expect(CypressOnRails.configuration.before_request).to_not be_nil
     expect(CypressOnRails.configuration.vcr_options).to eq({})
+    expect(CypressOnRails.configuration.server_readiness_path).to eq('/')
+    expect(CypressOnRails.configuration.server_readiness_timeout).to eq(5)
   end
 
   it 'can be configured' do
@@ -22,6 +24,8 @@ RSpec.describe CypressOnRails::Configuration do
       config.logger = my_logger
       config.before_request = before_request_lambda
       config.vcr_options = { hook_into: :webmock }
+      config.server_readiness_path = '/health'
+      config.server_readiness_timeout = 10
     end
     expect(CypressOnRails.configuration.api_prefix).to eq('/api')
     expect(CypressOnRails.configuration.install_folder).to eq('my/path')
@@ -29,5 +33,7 @@ RSpec.describe CypressOnRails::Configuration do
     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)
+    expect(CypressOnRails.configuration.server_readiness_path).to eq('/health')
+    expect(CypressOnRails.configuration.server_readiness_timeout).to eq(10)
   end
 end