smartest 0.6.0.alpha1 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52a400f8b0fb05816a1adae02b69ce475d81bd63ad3516dded34fc47b3efc516
-  data.tar.gz: eeef5df2ac8161d3998fb942e7796ccfead8f7f8409b835c771fec4db7756137
+  metadata.gz: 60329ddc39f19de585b5eca7624d830188201867f12acc4c5d455086770c6e55
+  data.tar.gz: e3b94d9094456040638436153dea247c90a09df900f73fac8a446e230cf121e6
 SHA512:
-  metadata.gz: 8336c21065222424824f95636730ab6ba1683fff0f711a3d37d180bebe6bac8cbf95be4c9bb8e0a794f0719fb5ba86102703d5af99902c1ab8461b5de0f6ab7c
-  data.tar.gz: 067c9a2f862cf07035b50bc8783e92f919a68ec8000546b2ab96e0ed2bde7c8cb0b811d99f7e9bf8bb2983d85ac7883fd830a38f86930c5a688b6e800f459fb7
+  metadata.gz: 47ba0913bb68d3015905baa12677ed6ac2f812723935a546d0f6f9c0e0154776fb72a9e2844a77833743c97a8363066c7199c767022022b17f169415c48b9001
+  data.tar.gz: 86f5bdd1c49b6f461408c5ee21075a0a75406e8f6c139f6146871fcbd0dea6644129e63339602851f2a122ac075d6bcc7b96d95d69224e446dc5e6031c951cf9

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Changelog
 
-## 0.6.0 (not published yet)
+## 0.6.1
+
+### Bug Fixes
+
+- Fix Rails Docker scaffold friction in `smartest --init-rails` and the
+  generated Playwright fixtures so the Docker-based browser test setup works
+  out of the box.
+
+### Documentation
+
+- Document fresh Rails database preparation for browser tests, including the
+  Docker-based workflow.
+
+## 0.6.0
 
 ### New Features
 

data/README.md

@@ -256,15 +256,43 @@ smartest/matchers/playwright_matcher.rb
 smartest/example_rails_system_test.rb
 ```
 
-The generated fixture requires `smartest/rails` and starts
+The generated fixture requires `smartest/rails`, loads `config/environment`
+when `test_helper` requires the fixture file, and starts
 `Smartest::Rails::TestServer` against `Rails.application` in the same Ruby
-process as the test runner. `Smartest::Rails::TestServer` is only loaded by
-explicitly requiring `smartest/rails`; plain `require "smartest"` does not load
-Puma.
+process as the test runner. Loading Rails during helper setup makes app
+constants such as ActiveRecord models available inside test files and
+`around_test` hooks before per-test fixtures are resolved. The generated
+fixture forces `RAILS_ENV` and `RACK_ENV` to `test` before Rails boots.
+`Smartest::Rails::TestServer` is only loaded by explicitly requiring
+`smartest/rails`; plain `require "smartest"` does not load Puma.
+
+This is aimed at local Rails system tests that combine Rails test data, stubs,
+and Playwright browser assertions. It is not a Capybara compatibility layer or
+the main choice for staging / production-like E2E suites; use Node.js
+Playwright Test for that style of E2E testing.
 
 The generated `page` fixture uses a per-test Playwright browser context with
-`baseURL` set to the Rails server URL. Set `SMARTEST_RAILS_PORT` when you need a
-fixed port; otherwise the test server asks the OS for an available port.
+`baseURL` set to the Rails server URL. Set
+`SMARTEST_RAILS_TEST_SERVER_PORT` when you need a fixed port; otherwise the test
+server asks the OS for an available port.
+
+For Docker sidecar runs, initialize without installing browser binaries into
+the Rails app container:
+
+```bash
+SMARTEST_SKIP_BROWSER_DOWNLOAD=1 bundle exec smartest --init-rails
+```
+
+At runtime, set `PLAYWRIGHT_WS_ENDPOINT`,
+`SMARTEST_RAILS_TEST_SERVER_HOST`, `SMARTEST_RAILS_TEST_SERVER_PORT`, and
+`SMARTEST_RAILS_BASE_URL` so the generated fixture connects to the Playwright
+sidecar and gives the browser a Docker-network URL for Rails. These are usually
+stable Docker topology settings, so put them in `compose.yml` instead of
+repeating them on every `docker compose run` command.
+For a Rails Compose service named `web`, use
+`SMARTEST_RAILS_BASE_URL=http://web:4001`; replace `web` with your service name.
+The generated Rails fixture sets `RAILS_ENV` and `RACK_ENV` to `test`, even if
+the same service normally runs in development.
 
 Run the generated Rails browser example with:
 

data/lib/smartest/init_browser_generator.rb

@@ -160,11 +160,15 @@ module Smartest
     end
 
     def install_dependencies
-      install_commands.each do |command|
-        @output.puts "run     #{command.join(" ")}"
-        next if @command_runner.call(command, chdir: @root)
+      commands = install_commands
 
-        raise "command failed: #{command.join(" ")}"
+      with_unbundled_env do
+        commands.each do |command|
+          @output.puts "run     #{command.join(" ")}"
+          next if @command_runner.call(command, chdir: @root)
+
+          raise "command failed: #{command.join(" ")}"
+        end
       end
     end
 
@@ -179,5 +183,15 @@ module Smartest
     def run_system_command(command, chdir:)
       system(*command, chdir: chdir)
     end
+
+    def with_unbundled_env(&block)
+      require "bundler"
+
+      if Bundler.respond_to?(:with_unbundled_env)
+        Bundler.with_unbundled_env(&block)
+      else
+        Bundler.with_clean_env(&block)
+      end
+    end
   end
 end

data/lib/smartest/init_rails_generator.rb

@@ -10,15 +10,19 @@ module Smartest
       require 'smartest/rails'
       require "playwright"
 
-      class RailsSystemFixture < Smartest::Fixture
-        suite_fixture :rails_server do
-          # Set the environment before loading config/environment so the test
-          # server cannot boot against the development database by default.
-          ENV["RAILS_ENV"] ||= "test"
-          ENV["RACK_ENV"] ||= ENV["RAILS_ENV"]
-          require_relative "../../config/environment"
+      # Force the test environment and load Rails while test_helper is required
+      # so app constants are available before per-test fixtures are resolved.
+      ENV["RAILS_ENV"] = "test"
+      ENV["RACK_ENV"] = "test"
+      require_relative "../../config/environment"
 
-          server = Smartest::Rails::TestServer.new(app: Rails.application)
+      class RailsSystemTestFixture < Smartest::Fixture
+        suite_fixture :rails_server do
+          server = Smartest::Rails::TestServer.new(
+            app: Rails.application,
+            host: ENV["SMARTEST_RAILS_TEST_SERVER_HOST"],
+            port: ENV["SMARTEST_RAILS_TEST_SERVER_PORT"],
+          )
           server.start
           server.wait_for_ready
 
@@ -31,36 +35,34 @@ module Smartest
         end
 
         suite_fixture :base_url do |rails_server:|
-          rails_server.base_url
+          ENV.fetch("SMARTEST_RAILS_BASE_URL", rails_server.base_url)
         end
 
-        suite_fixture :playwright do
-          runtime = Playwright.create(
-            playwright_cli_executable_path: "./node_modules/.bin/playwright",
-          )
-          on_teardown { runtime.stop }
-          runtime.playwright
-        end
+        suite_fixture :browser do
+          ws_endpoint = ENV["PLAYWRIGHT_WS_ENDPOINT"]
 
-        suite_fixture :browser do |playwright:|
-          browser_type = case ENV["BROWSER"]
-          when "firefox"
-            :firefox
-          when "webkit"
-            :webkit
-          else
-            :chromium
-          end
+          if ws_endpoint && !ws_endpoint.empty?
+            playwright_execution = Playwright.connect_to_browser_server(
+              ws_endpoint,
+              browser_type: selected_browser_type.to_s,
+            )
+            on_teardown { playwright_execution.stop }
 
-          launch_options = {}
-          launch_options[:headless] = !%w[0 false].include?(ENV["HEADLESS"])
-          if (slow_mo = ENV["SLOW_MO"].to_i) > 0
-            launch_options[:slowMo] = slow_mo
+            playwright_execution.browser
+          else
+            playwright_execution = Playwright.create(
+              playwright_cli_executable_path: ENV.fetch(
+                "PLAYWRIGHT_CLI_EXECUTABLE_PATH",
+                "./node_modules/.bin/playwright",
+              )
+            )
+            on_teardown { playwright_execution.stop }
+
+            playwright = playwright_execution.playwright
+            browser = playwright.public_send(selected_browser_type).launch(**browser_launch_options)
+            on_teardown { browser.close }
+            browser
           end
-
-          browser = playwright.send(browser_type).launch(**launch_options)
-          on_teardown { browser.close }
-          browser
         end
 
         fixture :browser_context do |base_url:, browser:|
@@ -74,6 +76,29 @@ module Smartest
           on_teardown { page.close }
           page
         end
+
+        private
+
+        def selected_browser_type
+          case ENV.fetch("BROWSER", "chromium")
+          when "firefox"
+            :firefox
+          when "webkit"
+            :webkit
+          else
+            :chromium
+          end
+        end
+
+        def browser_launch_options
+          launch_options = {}
+          launch_options[:headless] = !%w[0 false].include?(ENV.fetch("HEADLESS", "true"))
+          if (slow_mo = ENV.fetch("SLOW_MO", "0").to_i) > 0
+            launch_options[:slowMo] = slow_mo
+          end
+
+          launch_options
+        end
       end
     RUBY
 
@@ -156,7 +181,7 @@ module Smartest
 
     def ensure_rails_registered(contents)
       missing_lines = []
-      missing_lines << "  use_fixture RailsSystemFixture\n" unless contents.include?("use_fixture RailsSystemFixture")
+      missing_lines << "  use_fixture RailsSystemTestFixture\n" unless contents.include?("use_fixture RailsSystemTestFixture")
       missing_lines << "  use_matcher PlaywrightMatcher\n" unless contents.include?("use_matcher PlaywrightMatcher")
       return contents if missing_lines.empty?
 
@@ -186,11 +211,19 @@ module Smartest
     end
 
     def install_dependencies
-      install_commands.each do |command|
-        @output.puts "run     #{command.join(" ")}"
-        next if @command_runner.call(command, chdir: @root)
+      commands = install_commands
+
+      with_unbundled_env do
+        commands.each do |command|
+          @output.puts "run     #{command.join(" ")}"
+          next if @command_runner.call(command, chdir: @root)
 
-        raise "command failed: #{command.join(" ")}"
+          raise "command failed: #{command.join(" ")}"
+        end
+      end
+
+      if skip_browser_download?
+        @output.puts "skip    ./node_modules/.bin/playwright install (SMARTEST_SKIP_BROWSER_DOWNLOAD=1)"
       end
     end
 
@@ -198,12 +231,26 @@ module Smartest
       commands = [["bundle", "install"]]
       commands << ["npm", "init", "--yes"] unless File.exist?(File.join(@root, "package.json"))
       commands << ["npm", "install", "playwright", "--save-dev"]
-      commands << ["./node_modules/.bin/playwright", "install"]
+      commands << ["./node_modules/.bin/playwright", "install"] unless skip_browser_download?
       commands
     end
 
+    def skip_browser_download?
+      %w[1 true].include?(ENV.fetch("SMARTEST_SKIP_BROWSER_DOWNLOAD", "false"))
+    end
+
     def run_system_command(command, chdir:)
       system(*command, chdir: chdir)
     end
+
+    def with_unbundled_env(&block)
+      require "bundler"
+
+      if Bundler.respond_to?(:with_unbundled_env)
+        Bundler.with_unbundled_env(&block)
+      else
+        Bundler.with_clean_env(&block)
+      end
+    end
   end
 end

data/lib/smartest/rails.rb

@@ -9,15 +9,14 @@ require_relative "../smartest"
 module Smartest
   module Rails
     class TestServer
-      DEFAULT_HOST = "127.0.0.1"
       DEFAULT_READY_TIMEOUT = 10
 
       attr_reader :host, :port
 
-      def initialize(app:, host: DEFAULT_HOST, port: nil)
+      def initialize(app:, host: nil, port: nil)
         @app = app
-        @host = host
-        @requested_port = port || ENV["SMARTEST_RAILS_PORT"]&.to_i || 0
+        @host = host || "127.0.0.1"
+        @requested_port = port ? port.to_i : 0
         @server = Puma::Server.new(@app)
         @port = bind_tcp_listener
         @thread = nil

data/lib/smartest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Smartest
-  VERSION = "0.6.0.alpha1"
+  VERSION = "0.6.1"
 end

data/smartest/smartest_test.rb

@@ -9,6 +9,8 @@ require "open3"
 require "tmpdir"
 
 module SmartestSelfTest
+  ENV_MISSING = Object.new.freeze
+
   module_function
 
   def test_case(name, block)
@@ -40,6 +42,20 @@ module SmartestSelfTest
   else
     raise Smartest::AssertionFailed, "expected #{expected_error}, but nothing was raised"
   end
+
+  def with_env(values)
+    previous_values = {}
+    values.each do |key, value|
+      previous_values[key] = ENV.fetch(key, ENV_MISSING)
+      value.nil? ? ENV.delete(key) : ENV[key] = value
+    end
+
+    yield
+  ensure
+    previous_values.each do |key, value|
+      value.equal?(ENV_MISSING) ? ENV.delete(key) : ENV[key] = value
+    end
+  end
 end
 
 class SelfTestRegisteredFixture < Smartest::Fixture
@@ -2167,6 +2183,49 @@ test("cli browser init generator creates Playwright scaffold and installation co
   end
 end
 
+test("cli browser init generator runs installation commands outside the current Bundler environment") do
+  require "bundler"
+
+  Dir.mktmpdir do |dir|
+    File.write(File.join(dir, "Gemfile"), <<~RUBY)
+      source "https://rubygems.org"
+
+      gem "smartest"
+    RUBY
+
+    command_environments = []
+    output = StringIO.new
+    generator = Smartest::InitBrowserGenerator.new(
+      root: dir,
+      output: output,
+      command_runner: ->(_command, chdir:) {
+        command_environments << {
+          bundle_gemfile: ENV["BUNDLE_GEMFILE"],
+          bundle_bin_path: ENV["BUNDLE_BIN_PATH"],
+          rubyopt: ENV["RUBYOPT"]
+        }
+        true
+      }
+    )
+
+    SmartestSelfTest.with_env(
+      "BUNDLE_GEMFILE" => File.join(dir, "Gemfile"),
+      "BUNDLE_BIN_PATH" => "/tmp/smartest-self-test-bundle",
+      "RUBYOPT" => "-rbundler/setup -W0"
+    ) do
+      status = generator.run
+      expect(status).to eq(0)
+    end
+
+    expect(command_environments.length).to eq(4)
+    expect(command_environments.all? do |environment|
+      environment[:bundle_gemfile].nil? &&
+        environment[:bundle_bin_path].nil? &&
+        !environment[:rubyopt].to_s.include?("bundler/setup")
+    end).to eq(true)
+  end
+end
+
 test("cli browser init generator skips npm init when package.json already exists") do
   Dir.mktmpdir do |dir|
     File.write(File.join(dir, "Gemfile"), <<~RUBY)
@@ -2230,7 +2289,7 @@ test("smartest rails helper is loaded only by explicit require") do
   end
 end
 
-test("smartest rails test server wraps puma with env port and lifecycle") do
+test("smartest rails test server wraps puma with explicit arguments and lifecycle") do
   lib_path = File.expand_path("../lib", __dir__)
 
   Dir.mktmpdir do |dir|
@@ -2269,25 +2328,32 @@ test("smartest rails test server wraps puma with env port and lifecycle") do
     RUBY
 
     stdout, stderr, status = Open3.capture3(
-      { "RUBYLIB" => "#{dir}:#{lib_path}", "SMARTEST_RAILS_PORT" => "4567" },
+      {
+        "RUBYLIB" => "#{dir}:#{lib_path}",
+        "SMARTEST_RAILS_TEST_SERVER_HOST" => "0.0.0.0",
+        "SMARTEST_RAILS_TEST_SERVER_PORT" => "9876",
+        "SMARTEST_RAILS_BASE_URL" => "http://app:9876"
+      },
       "ruby",
       "-e",
       <<~'RUBY'
         require "smartest/rails"
 
-        server = Smartest::Rails::TestServer.new(app: Object.new)
+        server = Smartest::Rails::TestServer.new(app: Object.new, port: "4567")
+        default_port_server = Smartest::Rails::TestServer.new(app: Object.new)
         thread = server.start
         server.stop
         server.wait_for_stopped
 
         puts server.base_url
+        puts default_port_server.base_url
         puts thread.is_a?(Thread)
       RUBY
     )
 
     expect(status.success?).to eq(true)
     expect(stderr).to eq("")
-    expect(stdout).to eq("http://127.0.0.1:4567\ntrue\n")
+    expect(stdout).to eq("http://127.0.0.1:4567\nhttp://127.0.0.1:4321\ntrue\n")
   end
 end
 
@@ -2316,14 +2382,42 @@ test("cli rails init generator creates Rails browser scaffold and installation c
     expect(status).to eq(0)
     rails_fixture = File.read(File.join(dir, "smartest/fixtures/rails_system_fixture.rb"))
     expect(rails_fixture).to include("require 'smartest/rails'")
-    expect(rails_fixture).to include("class RailsSystemFixture < Smartest::Fixture")
+    expect(rails_fixture).to include("class RailsSystemTestFixture < Smartest::Fixture")
     expect(rails_fixture).to include("suite_fixture :rails_server")
-    expect(rails_fixture).to include("server cannot boot against the development database")
+    expect(rails_fixture).to include('ENV["RAILS_ENV"] = "test"')
+    expect(rails_fixture).to include('ENV["RACK_ENV"] = "test"')
+    expect(rails_fixture).not_to include('ENV["RAILS_ENV"] ||=')
+    expect(rails_fixture).to include("constants are available before per-test fixtures are resolved")
     expect(rails_fixture).to include('require_relative "../../config/environment"')
-    expect(rails_fixture).to include("Smartest::Rails::TestServer.new(app: Rails.application)")
+    expect(rails_fixture.index('require_relative "../../config/environment"') < rails_fixture.index("class RailsSystemTestFixture")).to eq(true)
+    expect(rails_fixture).to include("Smartest::Rails::TestServer.new(")
+    expect(rails_fixture).to include('host: ENV["SMARTEST_RAILS_TEST_SERVER_HOST"]')
+    expect(rails_fixture).not_to include("bind_host:")
+    expect(rails_fixture).to include('port: ENV["SMARTEST_RAILS_TEST_SERVER_PORT"]')
+    expect(rails_fixture).not_to include("public_base_url")
     expect(rails_fixture).not_to include("SmartestRailsTestServer")
     expect(rails_fixture).not_to include("Puma::Server")
     expect(rails_fixture).to include("suite_fixture :base_url")
+    expect(rails_fixture).to include('ENV.fetch("SMARTEST_RAILS_BASE_URL", rails_server.base_url)')
+    expect(rails_fixture).not_to include("rails_test_server_port")
+    expect(rails_fixture).not_to include("SMARTEST_RAILS_PORT")
+    expect(rails_fixture).to include('ws_endpoint = ENV["PLAYWRIGHT_WS_ENDPOINT"]')
+    expect(rails_fixture).not_to include("suite_fixture :playwright_execution")
+    expect(rails_fixture).not_to include("suite_fixture :playwright do")
+    expect(rails_fixture).not_to include("Playwright.connect_to_playwright_server")
+    expect(rails_fixture).not_to include("rescue NotImplementedError")
+    expect(rails_fixture).to include("playwright_execution = Playwright.connect_to_browser_server(")
+    expect(rails_fixture).to include("browser_type: selected_browser_type.to_s")
+    expect(rails_fixture).to include("playwright_execution.browser")
+    expect(rails_fixture).to include('ENV.fetch(')
+    expect(rails_fixture).to include('"PLAYWRIGHT_CLI_EXECUTABLE_PATH"')
+    expect(rails_fixture).to include("suite_fixture :browser do")
+    expect(rails_fixture).to include("playwright_execution = Playwright.create(")
+    expect(rails_fixture).to include("on_teardown { playwright_execution.stop }")
+    expect(rails_fixture).to include("playwright = playwright_execution.playwright")
+    expect(rails_fixture).to include("playwright.public_send(selected_browser_type).launch(**browser_launch_options)")
+    expect(rails_fixture).to include("def selected_browser_type")
+    expect(rails_fixture).to include("def browser_launch_options")
     expect(rails_fixture).to include("fixture :browser_context do |base_url:, browser:|")
     expect(rails_fixture).to include("context = browser.new_context(baseURL: base_url)")
     expect(rails_fixture).to include("fixture :page do |browser_context:|")
@@ -2334,7 +2428,7 @@ test("cli rails init generator creates Rails browser scaffold and installation c
     expect(example_test).to include("expect(response.status).to be_between(200, 599)")
 
     helper_contents = File.read(File.join(dir, "smartest/test_helper.rb"))
-    expect(helper_contents).to include("use_matcher PredicateMatcher\n  use_fixture RailsSystemFixture\n  use_matcher PlaywrightMatcher\n  suite.run")
+    expect(helper_contents).to include("use_matcher PredicateMatcher\n  use_fixture RailsSystemTestFixture\n  use_matcher PlaywrightMatcher\n  suite.run")
     expect(helper_contents).not_to include("Smartest::SimpleStub")
 
     gemfile_contents = File.read(File.join(dir, "Gemfile"))
@@ -2351,6 +2445,150 @@ test("cli rails init generator creates Rails browser scaffold and installation c
   end
 end
 
+test("cli rails init generator forces Rails test environment when the generated fixture is required") do
+  Dir.mktmpdir do |dir|
+    FileUtils.mkdir_p(File.join(dir, "config"))
+    File.write(File.join(dir, "Gemfile"), <<~RUBY)
+      source "https://rubygems.org"
+
+      gem "rails"
+      gem "smartest"
+    RUBY
+    File.write(File.join(dir, "config/environment.rb"), <<~RUBY)
+      raise "RAILS_ENV was not set before loading Rails" unless ENV["RAILS_ENV"] == "test"
+      raise "RACK_ENV was not set before loading Rails" unless ENV["RACK_ENV"] == "test"
+
+      class User
+      end
+    RUBY
+
+    stub_dir = File.join(dir, "stub_load_path")
+    FileUtils.mkdir_p(File.join(stub_dir, "smartest"))
+    File.write(File.join(stub_dir, "smartest/rails.rb"), <<~RUBY)
+      module Smartest
+        class Fixture
+          def self.suite_fixture(*)
+          end
+
+          def self.fixture(*)
+          end
+        end
+
+        module Rails
+        end
+      end
+    RUBY
+    File.write(File.join(stub_dir, "playwright.rb"), "")
+
+    generator = Smartest::InitRailsGenerator.new(
+      root: dir,
+      output: StringIO.new,
+      command_runner: ->(_command, chdir:) { true }
+    )
+    generator.run
+
+    stdout, stderr, status = Open3.capture3(
+      {
+        "RUBYLIB" => stub_dir,
+        "RAILS_ENV" => "development",
+        "RACK_ENV" => "development"
+      },
+      "ruby",
+      "-e",
+      <<~RUBY
+        require #{File.join(dir, "smartest/fixtures/rails_system_fixture").inspect}
+        puts User.name
+      RUBY
+    )
+
+    expect(status.success?).to eq(true)
+    expect(stderr).to eq("")
+    expect(stdout).to eq("User\n")
+  end
+end
+
+test("cli rails init generator runs installation commands outside the current Bundler environment") do
+  require "bundler"
+
+  Dir.mktmpdir do |dir|
+    File.write(File.join(dir, "Gemfile"), <<~RUBY)
+      source "https://rubygems.org"
+
+      gem "rails"
+      gem "smartest"
+    RUBY
+
+    command_environments = []
+    output = StringIO.new
+    generator = Smartest::InitRailsGenerator.new(
+      root: dir,
+      output: output,
+      command_runner: ->(_command, chdir:) {
+        command_environments << {
+          bundle_gemfile: ENV["BUNDLE_GEMFILE"],
+          bundle_bin_path: ENV["BUNDLE_BIN_PATH"],
+          rubyopt: ENV["RUBYOPT"]
+        }
+        true
+      }
+    )
+
+    SmartestSelfTest.with_env(
+      "BUNDLE_GEMFILE" => File.join(dir, "Gemfile"),
+      "BUNDLE_BIN_PATH" => "/tmp/smartest-self-test-bundle",
+      "RUBYOPT" => "-rbundler/setup -W0"
+    ) do
+      status = generator.run
+      expect(status).to eq(0)
+    end
+
+    expect(command_environments.length).to eq(4)
+    expect(command_environments.all? do |environment|
+      environment[:bundle_gemfile].nil? &&
+        environment[:bundle_bin_path].nil? &&
+        !environment[:rubyopt].to_s.include?("bundler/setup")
+    end).to eq(true)
+  end
+end
+
+test("cli rails init generator skips browser install when requested by environment") do
+  SmartestSelfTest.with_env("SMARTEST_SKIP_BROWSER_DOWNLOAD" => "1") do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "Gemfile"), <<~RUBY)
+        source "https://rubygems.org"
+
+        gem "rails"
+        gem "smartest"
+      RUBY
+
+      commands = []
+      output = StringIO.new
+      generator = Smartest::InitRailsGenerator.new(
+        root: dir,
+        output: output,
+        command_runner: ->(command, chdir:) {
+          commands << [command, chdir]
+          true
+        }
+      )
+
+      status = generator.run
+
+      expect(status).to eq(0)
+      expect(commands).to eq(
+        [
+          [["bundle", "install"], dir],
+          [["npm", "init", "--yes"], dir],
+          [["npm", "install", "playwright", "--save-dev"], dir]
+        ]
+      )
+      expect(output.string).to include("skip    ./node_modules/.bin/playwright install (SMARTEST_SKIP_BROWSER_DOWNLOAD=1)")
+      expect(File.exist?(File.join(dir, "smartest/fixtures/rails_system_fixture.rb"))).to eq(true)
+      expect(File.exist?(File.join(dir, "smartest/example_rails_system_test.rb"))).to eq(true)
+    end
+  end
+end
+
 test("cli rails init generator skips duplicate registration and dependencies") do
   Dir.mktmpdir do |dir|
     FileUtils.mkdir_p(File.join(dir, "smartest/fixtures"))
@@ -2367,7 +2605,7 @@ test("cli rails init generator skips duplicate registration and dependencies") d
 
       around_suite do |suite|
         use_matcher PredicateMatcher
-        use_fixture RailsSystemFixture
+        use_fixture RailsSystemTestFixture
         use_matcher PlaywrightMatcher
         suite.run
       end
@@ -2388,7 +2626,7 @@ test("cli rails init generator skips duplicate registration and dependencies") d
 
     expect(status).to eq(0)
     helper_contents = File.read(File.join(dir, "smartest/test_helper.rb"))
-    expect(helper_contents.scan("use_fixture RailsSystemFixture").length).to eq(1)
+    expect(helper_contents.scan("use_fixture RailsSystemTestFixture").length).to eq(1)
     expect(helper_contents.scan("use_matcher PlaywrightMatcher").length).to eq(1)
     expect(helper_contents).not_to include("Smartest::SimpleStub")
     expect(commands).to eq(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.6.0.alpha1
+  version: 0.6.1
 platform: ruby
 authors:
 - Yusuke Iwaki
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-07 00:00:00.000000000 Z
+date: 2026-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -103,9 +103,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.19
 signing_key: