playwright-on-rails 0.7.1

data/lib/playwright-on-rails/config.rb

@@ -0,0 +1,41 @@
+require_relative "env"
+
+module PlaywrightOnRails
+  class Config
+    attr_accessor :rails_dir, :playwright_dir, :host, :port, :base_path, :transactional_server, :playwright_cli_opts
+
+    def initialize(
+      rails_dir: Env.fetch("PLAYWRIGHT_RAILS_DIR", default: Dir.pwd),
+      playwright_dir: Env.fetch("PLAYWRIGHT_RAILS_PLAYWRIGHT_DIR", default: rails_dir),
+      host: Env.fetch("PLAYWRIGHT_RAILS_HOST", default: "127.0.0.1"),
+      port: Env.fetch("PLAYWRIGHT_RAILS_PORT"),
+      base_path: Env.fetch("PLAYWRIGHT_RAILS_BASE_PATH", default: "/"),
+      transactional_server: Env.fetch("PLAYWRIGHT_RAILS_TRANSACTIONAL_SERVER", type: :boolean, default: true),
+      playwright_cli_opts: Env.fetch("PLAYWRIGHT_RAILS_PLAYWRIGHT_OPTS", default: "")
+    )
+      @rails_dir = rails_dir
+      @playwright_dir = playwright_dir
+      @host = host
+      @port = port
+      @base_path = base_path
+      @transactional_server = transactional_server
+      @playwright_cli_opts = playwright_cli_opts
+    end
+
+    def to_s
+      <<~DESC
+
+        playwright-on-rails configuration:
+        ============================
+         PLAYWRIGHT_RAILS_DIR.....................#{rails_dir.inspect}
+         PLAYWRIGHT_RAILS_PLAYWRIGHT_DIR.............#{playwright_dir.inspect}
+         PLAYWRIGHT_RAILS_HOST....................#{host.inspect}
+         PLAYWRIGHT_RAILS_PORT....................#{port.inspect}
+         PLAYWRIGHT_RAILS_BASE_PATH...............#{base_path.inspect}
+         PLAYWRIGHT_RAILS_TRANSACTIONAL_SERVER....#{transactional_server.inspect}
+         PLAYWRIGHT_RAILS_PLAYWRIGHT_OPTS............#{playwright_cli_opts.inspect}
+
+      DESC
+    end
+  end
+end

data/lib/playwright-on-rails/env.rb

@@ -0,0 +1,14 @@
+module PlaywrightOnRails
+  module Env
+    def self.fetch(name, type: :string, default: nil)
+      return default unless ENV.key?(name)
+
+      if type == :boolean
+        no_like_flag = ["", "0", "n", "no", "false"].include?(ENV.fetch(name))
+        !no_like_flag
+      else
+        ENV.fetch(name)
+      end
+    end
+  end
+end

data/lib/playwright-on-rails/finds_bin.rb

@@ -0,0 +1,16 @@
+require "pathname"
+
+module PlaywrightOnRails
+  class FindsBin
+    LOCAL_PATH = "node_modules/.bin/playwright"
+
+    def call(playwright_dir = Dir.pwd)
+      local_path = Pathname.new(playwright_dir).join(LOCAL_PATH)
+      if File.exist?(local_path)
+        local_path
+      else
+        "playwright"
+      end
+    end
+  end
+end

data/lib/playwright-on-rails/init.rb

@@ -0,0 +1,93 @@
+module PlaywrightOnRails
+  class Init
+    DEFAULT_CONFIG = <<~JS
+      import { defineConfig, devices } from '@playwright/test';
+
+      /**
+       * Read environment variables from file.
+       * https://github.com/motdotla/dotenv
+       */
+      // require('dotenv').config();
+
+      /**
+       * See https://playwright.dev/docs/test-configuration.
+       */
+      export default defineConfig({
+        testDir: './tests',
+        /* Run tests in files in parallel */
+        fullyParallel: true,
+        /* Fail the build on CI if you accidentally left test.only in the source code. */
+        forbidOnly: !!process.env.CI,
+        /* Retry on CI only */
+        retries: process.env.CI ? 2 : 0,
+        /* Opt out of parallel tests on CI. */
+        workers: process.env.CI ? 1 : undefined,
+        /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+        reporter: 'html',
+        /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+        use: {
+          /* Base URL to use in actions like `await page.goto('/')`. */
+          baseURL: process.env.PLAYWRIGHT_BASE_URL || 'http://127.0.0.1:3000',
+
+          /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+          trace: 'on-first-retry',
+        },
+
+        /* Configure projects for major browsers */
+        projects: [
+          {
+            name: 'chromium',
+            use: { ...devices['Desktop Chrome'] },
+          },
+
+          {
+            name: 'firefox',
+            use: { ...devices['Desktop Firefox'] },
+          },
+
+          {
+            name: 'webkit',
+            use: { ...devices['Desktop Safari'] },
+          },
+
+          /* Test against mobile viewports. */
+          // {
+          //   name: 'Mobile Chrome',
+          //   use: { ...devices['Pixel 5'] },
+          // },
+          // {
+          //   name: 'Mobile Safari',
+          //   use: { ...devices['iPhone 12'] },
+          // },
+
+          /* Test against branded browsers. */
+          // {
+          //   name: 'Microsoft Edge',
+          //   use: { ...devices['Desktop Edge'], channel: 'msedge' },
+          // },
+          // {
+          //   name: 'Google Chrome',
+          //   use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+          // },
+        ],
+
+        /* Run your local dev server before starting the tests */
+        // webServer: {
+        //   command: 'npm run start',
+        //   url: 'http://127.0.0.1:3000',
+        //   reuseExistingServer: !process.env.CI,
+        // },
+      });
+    JS
+
+    def call(playwright_dir = Config.new.playwright_dir)
+      config_path = File.join(playwright_dir, "playwright.config.js")
+      if !File.exist?(config_path)
+        File.write(config_path, DEFAULT_CONFIG)
+        puts "Playwright config initialized in `#{config_path}'"
+      else
+        warn "Playwright config already exists in `#{config_path}'. Skipping."
+      end
+    end
+  end
+end

data/lib/playwright-on-rails/initializer_hooks.rb

@@ -0,0 +1,53 @@
+module PlaywrightOnRails
+  def self.hooks
+    InitializerHooks.instance
+  end
+
+  class InitializerHooks
+    def self.instance
+      @instance ||= new
+    end
+
+    def before_server_start(&blk)
+      register(:before_server_start, blk)
+    end
+
+    def after_server_start(&blk)
+      register(:after_server_start, blk)
+    end
+
+    def after_transaction_start(&blk)
+      register(:after_transaction_start, blk)
+    end
+
+    def after_state_reset(&blk)
+      register(:after_state_reset, blk)
+    end
+
+    def before_server_stop(&blk)
+      register(:before_server_stop, blk)
+    end
+
+    def reset!
+      @hooks = {}
+    end
+
+    def run(name)
+      return unless @hooks[name]
+      @hooks[name].each do |blk|
+        blk.call
+      end
+    end
+
+    private
+
+    def register(name, blk)
+      @hooks[name] ||= []
+      @hooks[name] << blk
+    end
+
+    def initialize
+      reset!
+    end
+  end
+end

data/lib/playwright-on-rails/launches_playwright.rb

@@ -0,0 +1,63 @@
+require_relative "finds_bin"
+require_relative "config"
+require_relative "initializer_hooks"
+require_relative "manages_transactions"
+require_relative "starts_rails_server"
+
+module PlaywrightOnRails
+  class LaunchesPlaywright
+    def initialize
+      @initializer_hooks = InitializerHooks.instance
+      @manages_transactions = ManagesTransactions.instance
+      @starts_rails_server = StartsRailsServer.new
+      @finds_bin = FindsBin.new
+    end
+
+    def call(command, config)
+      puts config
+      @initializer_hooks.run(:before_server_start)
+      if config.transactional_server
+        @manages_transactions.begin_transaction
+      end
+      server = @starts_rails_server.call(
+        host: config.host,
+        port: config.port,
+        transactional_server: config.transactional_server
+      )
+      bin = @finds_bin.call(config.playwright_dir)
+
+      set_exit_hooks!(config)
+
+      command = <<~EXEC
+        PLAYWRIGHT_BASE_URL="http://#{server.host}:#{server.port}#{config.base_path}" "#{bin}" #{command} --config "#{config.playwright_dir}/playwright.config.js" #{config.playwright_cli_opts}
+      EXEC
+
+      puts "\nLaunching Playwright…\n$ #{command}\n"
+      system command
+    end
+
+    private
+
+    def set_exit_hooks!(config)
+      at_exit do
+        run_exit_hooks_if_necessary!(config)
+      end
+      Signal.trap("INT") do
+        puts "Exiting playwright-on-rails…"
+        exit
+      end
+    end
+
+    def run_exit_hooks_if_necessary!(config)
+      @at_exit_hooks_have_fired ||= false # avoid warning
+      return if @at_exit_hooks_have_fired
+
+      if config.transactional_server
+        @manages_transactions.rollback_transaction
+      end
+      @initializer_hooks.run(:before_server_stop)
+
+      @at_exit_hooks_have_fired = true
+    end
+  end
+end

data/lib/playwright-on-rails/manages_transactions.rb

@@ -0,0 +1,78 @@
+require_relative "initializer_hooks"
+
+module PlaywrightOnRails
+  class ManagesTransactions
+    def self.instance
+      @instance ||= new
+    end
+
+    def begin_transaction
+      @connections = gather_connections
+      @connections.each do |connection|
+        connection.begin_transaction joinable: false, _lazy: false
+        connection.pool.lock_thread = true
+      end
+
+      # When connections are established in the future, begin a transaction too
+      @connection_subscriber = ActiveSupport::Notifications.subscribe("!connection.active_record") { |_, _, _, _, payload|
+        if payload.key?(:spec_name) && (spec_name = payload[:spec_name])
+          setup_shared_connection_pool
+
+          begin
+            connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name)
+          rescue ActiveRecord::ConnectionNotEstablished
+            connection = nil
+          end
+
+          if connection && !@connections.include?(connection)
+            connection.begin_transaction joinable: false, _lazy: false
+            connection.pool.lock_thread = true
+            @connections << connection
+          end
+        end
+      }
+
+      @initializer_hooks.run(:after_transaction_start)
+    end
+
+    def rollback_transaction
+      return unless @connections.present?
+
+      ActiveSupport::Notifications.unsubscribe(@connection_subscriber) if @connection_subscriber
+
+      @connections.each do |connection|
+        connection.rollback_transaction if connection.transaction_open?
+        connection.pool.lock_thread = false
+      end
+      @connections.clear
+
+      ActiveRecord::Base.connection_handler.clear_active_connections!
+    end
+
+    private
+
+    def initialize
+      @initializer_hooks = InitializerHooks.instance
+    end
+
+    def gather_connections
+      setup_shared_connection_pool
+
+      ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection)
+    end
+
+    # Shares the writing connection pool with connections on
+    # other handlers.
+    #
+    # In an application with a primary and replica the test fixtures
+    # need to share a connection pool so that the reading connection
+    # can see data in the open transaction on the writing connection.
+    def setup_shared_connection_pool
+      return unless ActiveRecord::TestFixtures.respond_to?(:setup_shared_connection_pool)
+      @legacy_saved_pool_configs ||= Hash.new { |hash, key| hash[key] = {} }
+      @saved_pool_configs ||= Hash.new { |hash, key| hash[key] = {} }
+
+      ActiveRecord::TestFixtures.instance_method(:setup_shared_connection_pool).bind(self).call
+    end
+  end
+end

data/lib/playwright-on-rails/open.rb

@@ -0,0 +1,14 @@
+require_relative "launches_playwright"
+require_relative "config"
+
+module PlaywrightOnRails
+  class Open
+    def initialize
+      @launches_playwright = LaunchesPlaywright.new
+    end
+
+    def call(config = Config.new)
+      @launches_playwright.call("test --ui", config)
+    end
+  end
+end

data/lib/playwright-on-rails/railtie.rb

@@ -0,0 +1,12 @@
+require "rails/railtie"
+require "pathname"
+
+module PlaywrightOnRails
+  class Railtie < Rails::Railtie
+    railtie_name :"playwright-on-rails"
+
+    rake_tasks do
+      load Pathname.new(__dir__).join("rake.rb")
+    end
+  end
+end

data/lib/playwright-on-rails/rake.rb

@@ -0,0 +1,18 @@
+require "pathname"
+CLI = Pathname.new(File.dirname(__FILE__)).join("../../exe/playwright-on-rails")
+
+desc "Initialize playwright.config.js"
+task :"playwright:init" do
+  system "#{CLI} init"
+end
+
+desc "Open interactive Playwright app for developing tests"
+task :"playwright:open" do
+  trap("SIGINT") {} # avoid traceback
+  system "#{CLI} open"
+end
+
+desc "Run Playwright tests headlessly"
+task :"playwright:run" do
+  abort unless system "#{CLI} run"
+end

data/lib/playwright-on-rails/resets_state.rb

@@ -0,0 +1,20 @@
+require_relative "config"
+require_relative "manages_transactions"
+require_relative "initializer_hooks"
+
+module PlaywrightOnRails
+  class ResetsState
+    def initialize
+      @manages_transactions = ManagesTransactions.instance
+      @initializer_hooks = InitializerHooks.instance
+    end
+
+    def call(transactional_server:)
+      if transactional_server
+        @manages_transactions.rollback_transaction
+        @manages_transactions.begin_transaction
+      end
+      @initializer_hooks.run(:after_state_reset)
+    end
+  end
+end

data/lib/playwright-on-rails/run.rb

@@ -0,0 +1,14 @@
+require_relative "launches_playwright"
+require_relative "config"
+
+module PlaywrightOnRails
+  class Run
+    def initialize
+      @launches_playwright = LaunchesPlaywright.new
+    end
+
+    def call(config = Config.new)
+      @launches_playwright.call("test", config)
+    end
+  end
+end

data/lib/playwright-on-rails/server/checker.rb

@@ -0,0 +1,42 @@
+module PlaywrightOnRails
+  class Server
+    class Checker
+      TRY_HTTPS_ERRORS = [EOFError, Net::ReadTimeout, Errno::ECONNRESET].freeze
+
+      def initialize(host, port)
+        @host, @port = host, port
+        @ssl = false
+      end
+
+      def request(&block)
+        ssl? ? https_request(&block) : http_request(&block)
+      rescue *TRY_HTTPS_ERRORS
+        res = https_request(&block)
+        @ssl = true
+        res
+      end
+
+      def ssl?
+        @ssl
+      end
+
+      private
+
+      def http_request(&block)
+        make_request(read_timeout: 2, &block)
+      end
+
+      def https_request(&block)
+        make_request(**ssl_options, &block)
+      end
+
+      def make_request(**options, &block)
+        Net::HTTP.start(@host, @port, options.merge(max_retries: 0), &block)
+      end
+
+      def ssl_options
+        {use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE}
+      end
+    end
+  end
+end

data/lib/playwright-on-rails/server/middleware.rb

@@ -0,0 +1,67 @@
+module PlaywrightOnRails
+  class Server
+    class Middleware
+      class Counter
+        def initialize
+          @value = []
+          @mutex = Mutex.new
+        end
+
+        def increment(uri)
+          @mutex.synchronize { @value.push(uri) }
+        end
+
+        def decrement(uri)
+          @mutex.synchronize { @value.delete_at(@value.index(uri) || @value.length) }
+        end
+
+        def positive?
+          @mutex.synchronize { @value.length.positive? }
+        end
+
+        def value
+          @mutex.synchronize { @value.dup }
+        end
+      end
+
+      attr_reader :error
+
+      def initialize(app, server_errors, extra_middleware = [])
+        @app = app
+        @extended_app = extra_middleware.inject(@app) { |ex_app, klass|
+          klass.new(ex_app)
+        }
+        @counter = Counter.new
+        @server_errors = server_errors
+      end
+
+      def pending_requests
+        @counter.value
+      end
+
+      def pending_requests?
+        @counter.positive?
+      end
+
+      def clear_error
+        @error = nil
+      end
+
+      def call(env)
+        if env["PATH_INFO"] == "/__identify__"
+          [200, {}, [@app.object_id.to_s]]
+        else
+          @counter.increment(env["REQUEST_URI"])
+          begin
+            @extended_app.call(env)
+          rescue *@server_errors => e
+            @error ||= e
+            raise e
+          ensure
+            @counter.decrement(env["REQUEST_URI"])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/playwright-on-rails/server/puma.rb

@@ -0,0 +1,31 @@
+module PlaywrightOnRails
+  class Server
+    module Puma
+      def self.create(app, port, host)
+        require "rack/handler/puma"
+
+        # If we just run the Puma Rack handler it installs signal handlers which prevent us from being able to interrupt tests.
+        # Therefore construct and run the Server instance ourselves.
+        # Rack::Handler::Puma.run(app, { Host: host, Port: port, Threads: "0:4", workers: 0, daemon: false }.merge(options))
+        default_options = {Host: host, Port: port, Threads: "0:4", workers: 0, daemon: false}
+        options = default_options # .merge(options)
+
+        conf = Rack::Handler::Puma.config(app, options)
+        conf.clamp
+        logger = (defined?(::Puma::LogWriter) ? ::Puma::LogWriter : ::Puma::Events).stdio
+
+        puma_ver = Gem::Version.new(::Puma::Const::PUMA_VERSION)
+        require_relative "patches/puma_ssl" if (Gem::Version.new("4.0.0")...Gem::Version.new("4.1.0")).cover? puma_ver
+
+        logger.log "Starting Puma..."
+        logger.log "* Version #{::Puma::Const::PUMA_VERSION} , codename: #{::Puma::Const::CODE_NAME}"
+        logger.log "* Min threads: #{conf.options[:min_threads]}, max threads: #{conf.options[:max_threads]}"
+
+        ::Puma::Server.new(conf.app, defined?(::Puma::LogWriter) ? nil : logger, conf.options).tap do |s|
+          s.binder.parse conf.options[:binds], s.respond_to?(:log_writer) ? s.log_writer : s.events
+          s.min_threads, s.max_threads = conf.options[:min_threads], conf.options[:max_threads] if s.respond_to?(:min_threads=)
+        end.run.join
+      end
+    end
+  end
+end

data/lib/playwright-on-rails/server/timer.rb

@@ -0,0 +1,24 @@
+module PlaywrightOnRails
+  class Server
+    class Timer
+      def initialize(expire_in)
+        @start = current
+        @expire_in = expire_in
+      end
+
+      def expired?
+        current - @start >= @expire_in
+      end
+
+      def stalled?
+        @start == current
+      end
+
+      private
+
+      def current
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end