panda-core 0.11.0 → 0.12.2

data/lib/panda/core/middleware.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "action_dispatch"
+
+module Rails
+  module Configuration
+    # Add a tiny compatibility layer so the proxy can be inspected and reset in tests.
+    class MiddlewareStackProxy
+      include Enumerable
+
+      def clear
+        operations.clear
+        delete_operations.clear
+        self
+      end
+
+      def each(&block)
+        to_stack.each { |mw| block.call(wrap_middleware(mw)) }
+      end
+
+      def to_a
+        map(&:itself)
+      end
+
+      def [](index)
+        to_a[index]
+      end
+
+      def first
+        to_a.first
+      end
+
+      def last
+        to_a.last
+      end
+
+      def size
+        to_a.size
+      end
+
+      private
+
+      def to_stack
+        ActionDispatch::MiddlewareStack.new.tap do |stack|
+          merge_into(stack)
+        end
+      end
+
+      def wrap_middleware(middleware)
+        args, kwargs = split_args_and_kwargs(middleware.args)
+        MiddlewareEntry.new(middleware.klass, args, kwargs, middleware.block)
+      end
+
+      def split_args_and_kwargs(args)
+        return [args, {}] unless args.last.is_a?(Hash)
+
+        [args[0...-1], args.last]
+      end
+
+      MiddlewareEntry = Struct.new(:klass, :args, :kwargs, :block)
+    end
+  end
+end
+
+module Panda
+  module Core
+    module Middleware
+      EXECUTOR = "ActionDispatch::Executor"
+
+      def self.use(app, klass, *args, **kwargs, &block)
+        app.config.middleware.use(klass, *args, **kwargs, &block)
+      end
+
+      def self.insert_before(app, priority_targets, klass, *args, **kwargs, &block)
+        stack = build_stack(app)
+        target = resolve_target(stack, priority_targets, :insert_before)
+        insertion_point = target || fallback_before(stack)
+        app.config.middleware.insert_before(insertion_point, klass, *args, **kwargs, &block)
+      end
+
+      def self.insert_after(app, priority_targets, klass, *args, **kwargs, &block)
+        stack = build_stack(app)
+        target = resolve_target(stack, priority_targets, :insert_after)
+        insertion_point = target || fallback_after(stack)
+        app.config.middleware.insert_after(insertion_point, klass, *args, **kwargs, &block)
+      end
+
+      #
+      # Helpers
+      #
+      def self.resolve_target(app_or_stack, priority_targets, _operation)
+        stack = normalize_stack(app_or_stack)
+        priority_targets.find { |candidate| middleware_exists?(stack, candidate) }
+      end
+      private_class_method :resolve_target
+
+      def self.middleware_exists?(app_or_stack, candidate)
+        stack = normalize_stack(app_or_stack)
+        stack.any? { |mw| middleware_matches?(mw.klass, candidate) }
+      end
+      private_class_method :middleware_exists?
+
+      def self.middleware_matches?(klass, candidate)
+        klass == candidate || klass.name == candidate.to_s
+      end
+      private_class_method :middleware_matches?
+
+      def self.fallback_before(stack)
+        executor_index = index_for(stack, EXECUTOR)
+        executor_index || 0
+      end
+      private_class_method :fallback_before
+
+      def self.fallback_after(stack)
+        executor_index = index_for(stack, EXECUTOR)
+        return executor_index + 1 if executor_index
+
+        stack_size = stack.size
+        stack_size.zero? ? 0 : stack_size - 1
+      end
+      private_class_method :fallback_after
+
+      def self.index_for(stack, target)
+        stack.each_with_index do |middleware, idx|
+          return idx if middleware_matches?(middleware.klass, target)
+        end
+        nil
+      end
+      private_class_method :index_for
+
+      def self.build_stack(app)
+        app.config.middleware.to_a
+      end
+      private_class_method :build_stack
+
+      def self.normalize_stack(app_or_stack)
+        if app_or_stack.respond_to?(:config) && app_or_stack.config.respond_to?(:middleware)
+          build_stack(app_or_stack)
+        else
+          app_or_stack
+        end
+      end
+      private_class_method :normalize_stack
+    end
+  end
+end

data/lib/panda/core/testing/rails_helper.rb

@@ -104,11 +104,6 @@ RSpec.configure do |config|
     ActionMailer::Base.logger = nil if defined?(ActionMailer)
   end
 
-  # Suppress Rails command output during generator tests
-  config.before(:each, type: :generator) do
-    allow(Rails::Command).to receive(:invoke).and_return(true)
-  end
-
   # Force all examples to run
   config.filter_run_including({})
   config.run_all_when_everything_filtered = true
@@ -169,14 +164,28 @@ RSpec.configure do |config|
   OmniAuth.config.test_mode = true if defined?(OmniAuth)
 
   # DatabaseCleaner configuration
+  config.around(:each) do |example|
+    DatabaseCleaner.strategy = (example.metadata[:type] == :system) ? :truncation : :transaction
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+
+  config.before(:each, type: :system) do
+    driven_by :panda_cuprite
+  end
+
+  config.use_transactional_fixtures = false
+
   config.before(:suite) do
     # Allow DATABASE_URL in CI environment
-    if ENV["DATABASE_URL"]
+    if ENV["DATABASE_URL"] &&
+        ENV["SKIP_DB_CLEAN_WITH_DATABASE_URL"].nil? &&
+        ENV["ACT"] != "true"
       DatabaseCleaner.allow_remote_database_url = true
+      DatabaseCleaner.clean_with(:truncation)
     end
 
-    DatabaseCleaner.clean_with :truncation
-
     # Hook for gems to add custom suite setup
     # Gems can define Panda::Testing.before_suite_hook and it will be called here
     if defined?(Panda::Testing) && Panda::Testing.respond_to?(:before_suite_hook)

data/lib/panda/core/testing/support/authentication_helpers.rb

@@ -4,18 +4,18 @@ module Panda
   module Core
     module AuthenticationHelpers
       # Create test users with fixed IDs for consistent fixture references
-      def create_admin_user
+      def create_admin_user(attributes = {})
         Panda::Core::User.find_or_create_by!(id: "8f481fcb-d9c8-55d7-ba17-5ea5d9ed8b7a") do |user|
-          user.email = "admin@test.example.com"
-          user.name = "Admin User"
+          user.email = attributes[:email] || "admin@test.example.com"
+          user.name = attributes[:name] || "Admin User"
           user.admin = true
         end
       end
 
-      def create_regular_user
+      def create_regular_user(attributes = {})
         Panda::Core::User.find_or_create_by!(id: "9a8b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d") do |user|
-          user.email = "user@test.example.com"
-          user.name = "Regular User"
+          user.email = attributes[:email] || "user@test.example.com"
+          user.name = attributes[:name] || "Regular User"
           user.admin = false
         end
       end

data/lib/panda/core/testing/support/authentication_test_helpers.rb

@@ -22,12 +22,7 @@ module Panda
           user.email = attributes[:email] || "admin@example.com"
           user.name = attributes[:name] || "Admin User"
           user.image_url = attributes[:image_url] || default_image_url
-          # Use is_admin for the actual column, but support both for compatibility
-          if user.respond_to?(:is_admin=)
-            user.is_admin = attributes.fetch(:admin, true)
-          elsif user.respond_to?(:admin=)
-            user.admin = attributes.fetch(:admin, true)
-          end
+          user.admin = attributes[:admin] || true
           # Only set OAuth fields if they exist on the model
           user.uid = attributes[:uid] || "admin_oauth_uid_123" if user.respond_to?(:uid=)
           user.provider = attributes[:provider] || "google_oauth2" if user.respond_to?(:provider=)
@@ -42,12 +37,7 @@ module Panda
           user.email = attributes[:email] || "user@example.com"
           user.name = attributes[:name] || "Regular User"
           user.image_url = attributes[:image_url] || default_image_url(dark: true)
-          # Use is_admin for the actual column, but support both for compatibility
-          if user.respond_to?(:is_admin=)
-            user.is_admin = attributes.fetch(:admin, false)
-          elsif user.respond_to?(:admin=)
-            user.admin = attributes.fetch(:admin, false)
-          end
+          user.admin = attributes[:admin] || false
           # Only set OAuth fields if they exist on the model
           user.uid = attributes[:uid] || "user_oauth_uid_456" if user.respond_to?(:uid=)
           user.provider = attributes[:provider] || "google_oauth2" if user.respond_to?(:provider=)

data/lib/panda/core/testing/support/system/browser_console_logger.rb

@@ -9,8 +9,7 @@ module BrowserConsoleLogger
 
       if respond_to?(:page) && page.driver.is_a?(Capybara::Cuprite::Driver)
         begin
-          # Access the console logger via the CupriteSetup module
-          console_logger = Panda::Core::Testing::CupriteSetup.console_logger
+          console_logger = Panda::Core::Testing::CupriteSetup.console_logger if defined?(Panda::Core::Testing::CupriteSetup)
 
           unless console_logger
             puts "\n⚠️  Console logger not available"

data/lib/panda/core/testing/support/system/chrome_path.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Testing
+      module Support
+        module System
+          module ChromePath
+            def self.resolve
+              @resolved ||= begin
+                candidates = [
+                  # Linux (Debian/Ubuntu + your CI image)
+                  "/usr/bin/chromium",
+                  "/usr/bin/chromium-browser",
+                  "/usr/bin/google-chrome",
+                  "/opt/google/chrome/google-chrome",
+                  "/opt/google/chrome/chrome",
+
+                  # macOS Homebrew paths (Chromium)
+                  "/opt/homebrew/bin/chromium",
+                  "/usr/local/bin/chromium",
+
+                  # macOS Google Chrome
+                  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+                  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+                  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+                ]
+
+                candidates.find { |path| File.executable?(path) } ||
+                  raise("Could not find a Chrome/Chromium binary on this system")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/panda/core/testing/support/system/cuprite_helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 # Helper methods for Cuprite-based system tests
 #
 # This module provides utility methods for working with Cuprite in system tests:
@@ -16,6 +18,83 @@ module Panda
   module Core
     module Testing
       module CupriteHelpers
+        # Resolve the configured Capybara artifacts directory
+        def capybara_artifacts_dir
+          Pathname.new(Capybara.save_path || Rails.root.join("tmp/capybara"))
+        end
+
+        # Save a PNG screenshot for the current page.
+        #
+        def save_screenshot!(name = nil)
+          name ||= example.metadata[:full_description].parameterize
+          path = capybara_artifacts_dir.join("#{name}.png")
+
+          FileUtils.mkdir_p(File.dirname(path))
+          page.save_screenshot(path, full: true) # rubocop:disable Lint/Debugger
+          puts "📸 Saved screenshot: #{path}"
+
+          path
+        end
+
+        #
+        # Record a small MP4 video of the test — uses Cuprite's Chrome DevTools API
+        #
+        def record_video!(name = nil, seconds: 3)
+          name ||= example.metadata[:full_description].parameterize
+          path = capybara_artifacts_dir.join("#{name}.mp4")
+
+          FileUtils.mkdir_p(File.dirname(path))
+
+          session = page.driver.browser
+          client = session.client
+
+          # Enable screencast
+          client.command("Page.startScreencast", format: "png", quality: 80, maxWidth: 1280, maxHeight: 800)
+
+          frames = []
+
+          start = Time.now
+          while Time.now - start < seconds
+            message = client.listen
+            if message["method"] == "Page.screencastFrame"
+              frames << message["params"]["data"]
+              client.command("Page.screencastFrameAck", sessionId: message["params"]["sessionId"])
+            end
+          end
+
+          # Stop
+          client.command("Page.stopScreencast")
+
+          # Convert frames to MP4 using ffmpeg
+          Dir.mktmpdir do |dir|
+            png_dir = File.join(dir, "frames")
+            FileUtils.mkdir_p(png_dir)
+
+            frames.each_with_index do |data, i|
+              File.binwrite(File.join(png_dir, "frame-%05d.png" % i), Base64.decode64(data))
+            end
+
+            system <<~CMD
+              ffmpeg -y -framerate 8 -pattern_type glob -i '#{png_dir}/*.png' -c:v libx264 -pix_fmt yuv420p '#{path}'
+            CMD
+          end
+
+          puts "🎥 Saved video: #{path}"
+          path
+        rescue => e
+          puts "⚠️ Failed to record video: #{e.message}"
+          nil
+        end
+
+        def save_html!(name = nil)
+          name ||= example.metadata[:full_description].parameterize
+          path = capybara_artifacts_dir.join("#{name}.html")
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, page.html)
+          puts "📝 Saved HTML snapshot: #{path}"
+          path
+        end
+
         # Ensure page is loaded and stable before interacting
         def ensure_page_loaded
           # Check if we're on about:blank and need to reload

data/lib/panda/core/testing/support/system/cuprite_setup.rb

@@ -1,54 +1,55 @@
-# frozen_string_literal: true
-
 require "ferrum"
 require "capybara/cuprite"
+require "tmpdir"
 require_relative "ferrum_console_logger"
-
-# Shared Cuprite driver configuration for all Panda gems
-# This provides standard Cuprite setup with sensible defaults that work across gems
-#
-# Features:
-# - :cuprite driver for standard desktop testing
-# - :cuprite_mobile driver for mobile viewport testing
-# - JavaScript error reporting enabled by default (js_errors: true)
-# - CI-optimized browser options
-# - Environment-based configuration (HEADLESS, INSPECTOR, SLOWMO)
+require_relative "chrome_path"
 
 module Panda
   module Core
     module Testing
       module CupriteSetup
-        # Class variable to store the console logger instance
-        # This allows tests to access console logs after they run
         @console_logger = nil
 
         class << self
           attr_accessor :console_logger
         end
 
-        # Base Cuprite options shared across all drivers
         def self.base_options
-          default_timeout = 2
-          default_process_timeout = 2
+          ci_default_timeout = 30
+          ci_default_process_timeout = 120
+          default_timeout = ENV["CI"] ? ci_default_timeout : 5
+          default_process_timeout = ENV["CI"] ? ci_default_process_timeout : 10
+
+          cuprite_timeout = ENV["CUPRITE_TIMEOUT"]&.to_i ||
+            ENV["FERRUM_TIMEOUT"]&.to_i ||
+            default_timeout
+
+          process_timeout_value = ENV["CUPRITE_PROCESS_TIMEOUT"]&.to_i ||
+            ENV["FERRUM_PROCESS_TIMEOUT"]&.to_i ||
+            default_process_timeout
+
+          puts "[Cuprite Config] timeout = #{cuprite_timeout}, process_timeout = #{process_timeout_value}" if ENV["CI"] || ENV["DEBUG"]
+          puts "[Cuprite Config] ENV: CUPRITE_TIMEOUT=#{ENV["CUPRITE_TIMEOUT"].inspect}, CUPRITE_PROCESS_TIMEOUT=#{ENV["CUPRITE_PROCESS_TIMEOUT"].inspect}" if ENV["CI"] || ENV["DEBUG"]
+
+          browser_path = ENV["BROWSER_PATH"] || Panda::Core::Testing::Support::System::ChromePath.resolve
 
           {
+            browser_path: browser_path,
             window_size: [1440, 1000],
             inspector: ENV["INSPECTOR"].in?(%w[y 1 yes true]),
             headless: !ENV["HEADLESS"].in?(%w[n 0 no false]),
             slowmo: ENV["SLOWMO"]&.to_f || 0,
-            timeout: ENV["CUPRITE_TIMEOUT"]&.to_i || default_timeout,
-            js_errors: true,  # IMPORTANT: Report JavaScript errors as test failures
+            timeout: cuprite_timeout,
+            js_errors: true,
             ignore_default_browser_options: false,
-            process_timeout: ENV["CUPRITE_PROCESS_TIMEOUT"]&.to_i || default_process_timeout,
-            wait_for_network_idle: false,  # Don't wait for all network requests
-            pending_connection_errors: false,  # Don't fail on pending external connections
+            process_timeout: process_timeout_value,
+            wait_for_network_idle: false,
+            pending_connection_errors: ENV["CI"] != "true",
+            max_conns: 1,
+            restart_if: {crashes: true, attempts: 2},
             browser_options: {
               "no-sandbox": nil,
               "disable-gpu": nil,
-              "disable-dev-shm-usage": nil,
-              "disable-background-networking": nil,
-              "disable-default-apps": nil,
-              "disable-extensions": nil,
               "disable-sync": nil,
               "disable-translate": nil,
               "no-first-run": nil,
@@ -56,71 +57,65 @@ module Panda
               "allow-insecure-localhost": nil,
               "enable-features": "NetworkService,NetworkServiceInProcess",
               "disable-blink-features": "AutomationControlled",
-              "no-dbus": true
+              "no-dbus": nil,
+              "log-level": ENV["CI"] ? "0" : "3"
             }
           }
         end
 
-        # Additional options for CI environments
         def self.ci_browser_options
           {
-            "disable-web-security": nil,
-            "allow-file-access-from-files": nil,
-            "allow-file-access": nil
+            "disable-web-security" => nil,
+            "allow-file-access-from-files" => nil,
+            "allow-file-access" => nil,
+            "disable-dev-shm-usage" => nil, # Sets shared memory in /tmp; don't use if lots of /dev/shm space
+            "no-sandbox" => nil
           }
         end
 
-        # Configure standard desktop driver
-        def self.register_desktop_driver
+        def self.register_panda_cuprite_driver(name: :panda_cuprite, window_size: [1280, 720])
           options = base_options.dup
+          options[:window_size] = window_size
+          options[:browser_options] = options[:browser_options].dup
+          options[:browser_options]["user-data-dir"] = Dir.mktmpdir("cuprite-profile")
 
-          # Add CI-specific options
-          if ENV["GITHUB_ACTIONS"] == "true"
+          if ENV["CI"] == "true" # Covers both act and GitHub Actions
             options[:browser_options].merge!(ci_browser_options)
-
-            # Ensure CI uses xvfb to run the browser
-            options[:browser_options][:xvfb] = true
           end
 
-          # Create console logger for capturing browser console messages
-          self.console_logger = Panda::Core::Testing::Support::System::FerrumConsoleLogger.new
-          options[:logger] = console_logger
-
-          Capybara.register_driver :cuprite do |app|
-            Capybara::Cuprite::Driver.new(app, **options)
-          end
-        end
-
-        # Configure mobile viewport driver
-        def self.register_mobile_driver
-          options = base_options.dup
-          options[:window_size] = [375, 667]  # iPhone SE size
-
-          if ENV["GITHUB_ACTIONS"] == "true"
-            options[:browser_options].merge!(ci_browser_options)
-          end
-
-          # Use the same console logger instance for mobile driver
           options[:logger] = console_logger if console_logger
 
-          Capybara.register_driver :cuprite_mobile do |app|
+          Capybara.register_driver name do |app|
             Capybara::Cuprite::Driver.new(app, **options)
           end
         end
 
-        # Register all drivers
         def self.setup!
-          register_desktop_driver
-          register_mobile_driver
-
-          # Set default drivers
-          Capybara.default_driver = :cuprite
-          Capybara.javascript_driver = :cuprite
+          register_panda_cuprite_driver(name: :panda_cuprite, window_size: [1280, 720])
+          register_panda_cuprite_driver(name: :panda_cuprite_mobile, window_size: [375, 667])
+          Capybara.default_driver = :panda_cuprite
+          Capybara.javascript_driver = :panda_cuprite
         end
       end
     end
   end
 end
 
-# Auto-setup when required
+Capybara.default_max_wait_time = ENV.fetch("CAPYBARA_MAX_WAIT_TIME", "5").to_i
+Capybara.raise_server_errors = true
+
+# Server selection (overridable via env)
+server_name = ENV.fetch("CAPYBARA_SERVER", "puma").to_sym
+Capybara.server = server_name
+Capybara.server_host = ENV.fetch("CAPYBARA_SERVER_HOST", "127.0.0.1")
+# Allow dynamic port by leaving blank
+port_env = ENV["CAPYBARA_PORT"]
+Capybara.server_port = (port_env && !port_env.empty?) ? port_env.to_i : nil
+app_host_env = ENV["CAPYBARA_APP_HOST"]
+Capybara.app_host = app_host_env unless app_host_env.to_s.empty?
+Capybara.always_include_port = !Capybara.app_host.nil?
+
+HEADLESS = !(ENV["HEADFUL"] == "true")
+
+# Register the drivers and setup the options
 Panda::Core::Testing::CupriteSetup.setup!

data/lib/panda/core/testing/support/system/system_test_helpers.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "cuprite_helpers"
-require_relative "better_system_tests"
 
 # Generic system test helpers for Cuprite-based testing
 # These methods work for any Rails application using Cuprite
@@ -11,7 +10,6 @@ module Panda
     module Testing
       module SystemTestHelpers
         include CupriteHelpers
-        include BetterSystemTests
       end
     end
   end
@@ -21,6 +19,13 @@ end
 RSpec.configure do |config|
   config.include Panda::Core::Testing::SystemTestHelpers, type: :system
 
+  tmp = ENV["TMPDIR"]
+  if tmp && File.world_writable?(tmp)
+    config.before(:suite) do
+      warn "⚠️  TMPDIR is world-writable: #{tmp}"
+    end
+  end
+
   # Make urls in mailers contain the correct server host
   config.around(:each, type: :system) do |ex|
     was_host = Rails.application.default_url_options[:host]
@@ -102,7 +107,9 @@ RSpec.configure do |config|
         nil
       end
 
-      # sleep 0.5
+      name = example.metadata[:full_description].parameterize
+
+      save_html!(name)
 
       # Get comprehensive page info
       page_html = begin
@@ -132,20 +139,13 @@ RSpec.configure do |config|
       end
 
       # Use Capybara's save_screenshot method
-      screenshot_path = Capybara.save_screenshot
+      screenshot_path = save_screenshot!(name)
       if screenshot_path
         puts "Screenshot saved to: #{screenshot_path}"
         puts "Page title: #{page_title}" if page_title.present?
         puts "Current URL: #{current_url}" if current_url.present?
         puts "Current path: #{current_path}" if current_path.present?
         puts "Page content length: #{page_html.length} characters"
-
-        # Save page HTML for debugging in CI
-        if ENV["GITHUB_ACTIONS"] && page_html.present?
-          html_debug_path = screenshot_path.gsub(".png", ".html")
-          File.write(html_debug_path, page_html)
-          puts "Page HTML saved to: #{html_debug_path}"
-        end
       end
     rescue => e
       puts "Failed to capture screenshot: #{e.message}"

data/lib/panda/core/version.rb

@@ -2,6 +2,6 @@
 
 module Panda
   module Core
-    VERSION = "0.11.0"
+    VERSION = "0.12.2"
   end
 end

data/lib/tasks/panda/core/users.rake

@@ -45,7 +45,7 @@ namespace :panda do
         if user.admin?
           puts "User '#{user.email}' is already an admin"
         else
-          user.update!(is_admin: true)
+          user.update!(admin: true)
           puts "✓ Granted admin privileges to '#{user.email}'"
         end
       end
@@ -75,7 +75,7 @@ namespace :panda do
             exit 1
           end
 
-          user.update!(is_admin: false)
+          user.update!(admin: false)
           puts "✓ Revoked admin privileges from '#{user.email}'"
         else
           puts "User '#{user.email}' is not an admin"
@@ -109,7 +109,7 @@ namespace :panda do
         user = Panda::Core::User.create!(
           email: email.downcase,
           name: name,
-          is_admin: true
+          admin: true
         )
         puts "✓ Created admin user '#{user.email}'"
         puts "  Name: #{user.name}" if user.respond_to?(:name)