playwright-rails 0.0.1

data/Gemfile.lock

@@ -0,0 +1,100 @@
+PATH
+  remote: .
+  specs:
+    playwright-rails (0.0.1)
+      puma (>= 6.1.1)
+      railties (>= 7.0.4.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (7.0.4.2)
+      actionview (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (7.0.4.2)
+      activesupport (= 7.0.4.2)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activesupport (7.0.4.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    builder (3.2.4)
+    concurrent-ruby (1.2.2)
+    crass (1.0.6)
+    erubi (1.12.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    loofah (2.19.1)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (1.0.0)
+    mini_portile2 (2.8.1)
+    minitest (5.15.0)
+    nio4r (2.5.8)
+    nokogiri (1.14.2)
+      mini_portile2 (~> 2.8.0)
+      racc (~> 1.4)
+    parallel (1.22.1)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    puma (6.1.1)
+      nio4r (~> 2.0)
+    racc (1.6.2)
+    rack (2.2.6.2)
+    rack-test (2.0.2)
+      rack (>= 1.3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.5.0)
+      loofah (~> 2.19, >= 2.19.1)
+    railties (7.0.4.2)
+      actionpack (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.4.0)
+    rexml (3.2.5)
+    rubocop (1.29.1)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.17.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.18.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    thor (1.2.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
+    zeitwerk (2.6.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  minitest (~> 5.0)
+  playwright-rails!
+  rake (~> 13.0)
+  rubocop (< 2)
+
+BUNDLED WITH
+   2.3.13

data/LICENSE.txt

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+
+Copyright (c) 2019-2020 Test Double, LLC
+
+Portions of the PlaywrightRails::Server component:
+Copyright (c) 2009-2018 Thomas Walpole, Jonas Nicklas
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+# playwright-rails

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "standard/rake"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: [:test, "standard:fix"]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "playwright-rails"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/playwright-rails

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+ENV["RAILS_ENV"] ||= "test"
+require "pathname"
+require "playwright-rails"
+require Pathname.new(PlaywrightRails::Config.new.dir).join("config/environment").to_s
+
+command = ARGV[0]
+case command
+when "open"
+  PlaywrightRails::Open.new.call
+when "run"
+  passed = PlaywrightRails::Run.new.call
+  exit 1 unless passed
+else
+  PlaywrightRails::LaunchesPlaywright.new.call(ARGV.join(" "))
+end

data/lib/playwright-rails/config.rb

@@ -0,0 +1,45 @@
+require_relative "env"
+
+module PlaywrightRails
+  class Config
+    attr_accessor(
+      :dir,
+      :host,
+      :port,
+      :base_path,
+      :transactional_server,
+      :playwright_cli_opts,
+    )
+
+    def initialize(
+      dir: Env.fetch("PLAYWRIGHT_RAILS_DIR", default: Dir.pwd),
+      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: "")
+    )
+      @dir = 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-rails configuration:
+        ============================
+         PLAYWRIGHT_RAILS_DIR.....................#{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-rails/env.rb

@@ -0,0 +1,14 @@
+module PlaywrightRails
+  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-rails/finds_bin.rb

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

data/lib/playwright-rails/initializer_hooks.rb

@@ -0,0 +1,53 @@
+module PlaywrightRails
+  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-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 PlaywrightRails
+  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 = Config.new)
+      puts config.to_s
+      @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.dir)
+
+      set_exit_hooks!(config)
+
+      command = <<~EXEC
+        BASE_URL="http://#{server.host}:#{server.port}#{config.base_path}" "#{bin}" #{command} #{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-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-rails/manages_transactions.rb

@@ -0,0 +1,79 @@
+require_relative "initializer_hooks"
+
+module PlaywrightRails
+  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
+
+      @connections.each(&: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-rails/open.rb

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

data/lib/playwright-rails/railtie.rb

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

data/lib/playwright-rails/rake.rb

@@ -0,0 +1,13 @@
+require "pathname"
+CLI = Pathname.new(File.dirname(__FILE__)).join("../../exe/playwright-rails")
+
+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-rails/resets_state.rb

@@ -0,0 +1,20 @@
+require_relative "config"
+require_relative "manages_transactions"
+require_relative "initializer_hooks"
+
+module PlaywrightRails
+  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-rails/run.rb

@@ -0,0 +1,14 @@
+require_relative "launches_playwright"
+require_relative "config"
+
+module PlaywrightRails
+  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-rails/server/checker.rb

@@ -0,0 +1,42 @@
+module PlaywrightRails
+  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-rails/server/middleware.rb

@@ -0,0 +1,67 @@
+module PlaywrightRails
+  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-rails/server/puma.rb

@@ -0,0 +1,31 @@
+module PlaywrightRails
+  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