smartest 0.6.0 → 0.6.2.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c8e44520f35d8daac5d01122fd2dc2b1f70f0fcbc61c1ff1d2a6c8ce5179a72
-  data.tar.gz: 4400e77b387079fa88978ff82d34b492f250fdf6de75aae773911a5b91672169
+  metadata.gz: 5eb327b86d510c4cf4e8ebdf31fcd7be3fe1b78c9109528ac99af08c3af1f9e4
+  data.tar.gz: 7937fde33ac1e62adb5f4bc39b54b938138af915008fcc350742f66420df5848
 SHA512:
-  metadata.gz: b5f7dde5de541b2eec20747164936cee3945076fb985c636d4ae2ea2473e0e2b795b9e5b393800b198e2bae5ae8c6e0892ab173d74e995404a1f4941ce27fd57
-  data.tar.gz: 0226224e48d5dfcaa82b9b22fc03ab295cab9fd463f5f0e17bab881d38e9f68eb98946641a45f5b6a13a884d1649c714a6e8aacd86e772b1aa6ec9d82fbf323c
+  metadata.gz: 8b011cea66dfec275fe790c0ced127819c23a18e70878bb9f4519d0e87b05e47c06b2b7bbc5de771ff3782cbb032409cb57be50ca2a2211fe79150a15a46b224
+  data.tar.gz: a77eb822acc8bb07f4f3b38a5f09bf3ca573fabb4542bc03b2e49120b110aad749042fe8004e38c733b0f4629f77673c371011382d7ab2d5e0881364c7a48595

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 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

@@ -227,11 +227,11 @@ smartest/matchers/playwright_matcher.rb
 smartest/example_browser_test.rb
 ```
 
-It also registers `PlaywrightFixture` and `PlaywrightMatcher`, adds
-`playwright-ruby-client` to the Gemfile test group, runs `bundle install`, runs
-`npm init --yes` when no `package.json` exists yet, runs
-`npm install playwright --save-dev`, and downloads Chromium with
-`./node_modules/.bin/playwright install`.
+It also registers `PlaywrightFixture` and `PlaywrightMatcher`, keeps or adds
+`smartest` in the Gemfile, adds `playwright-ruby-client` to the Gemfile test
+group, runs `bundle install`, runs `npm init --yes` when no `package.json`
+exists yet, runs `npm install playwright --save-dev`, and downloads Chromium
+with `./node_modules/.bin/playwright install`.
 
 Run the generated browser example with:
 
@@ -239,6 +239,9 @@ Run the generated browser example with:
 bundle exec smartest smartest/example_browser_test.rb
 ```
 
+The generated Playwright examples include `# @type [Playwright::Page] page`
+before the test block so RubyMine can complete methods on the `page` fixture.
+
 ## Rails browser quick start
 
 Initialize a Rails browser-test scaffold:
@@ -256,11 +259,15 @@ 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
@@ -282,7 +289,13 @@ 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.
+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:
 
@@ -318,6 +331,10 @@ end
 
 This makes fixture usage explicit and avoids relying on positional argument order.
 
+Smartest also ships RBS signatures for the public DSL, including `test`,
+`around_suite`, `around_test`, `fixture`, `suite_fixture`, `on_teardown`,
+`expect`, and hook registration methods such as `use_fixture`.
+
 ## Skipping and pending tests
 
 Use `skip` at the start of a test when the rest of the body should not run:

data/lib/smartest/init_browser_generator.rb

@@ -63,6 +63,7 @@ module Smartest
 
       require "test_helper"
 
+      # @type [Playwright::Page] page
       test("finds the smartest gem on RubyGems") do |page:|
         page.goto("https://rubygems.org/")
         page.locator("input[name='query']").fill("smartest")
@@ -147,24 +148,45 @@ module Smartest
       path = File.join(@root, "Gemfile")
       exists = File.exist?(path)
       contents = exists ? File.read(path) : "source \"https://rubygems.org\"\n"
+      updated = contents.dup
 
-      if contents.match?(/gem ["']playwright-ruby-client["']/)
+      unless gem_present?(updated, "smartest")
+        updated = append_gem(updated, 'gem "smartest"')
+      end
+
+      if gem_present?(updated, "playwright-ruby-client")
         @output.puts "exist   Gemfile playwright-ruby-client"
-        return
+      else
+        updated = append_gem(updated, 'gem "playwright-ruby-client", group: :test')
       end
 
+      if updated != contents
+        File.write(path, updated)
+        @output.puts(exists ? "update  Gemfile" : "create  Gemfile")
+      end
+    end
+
+    def append_gem(contents, line)
       separator = contents.end_with?("\n") ? "" : "\n"
-      updated = "#{contents}#{separator}\ngem \"playwright-ruby-client\", group: :test\n"
-      File.write(path, updated)
-      @output.puts(exists ? "update  Gemfile" : "create  Gemfile")
+      "#{contents}#{separator}\n#{line}\n"
+    end
+
+    def gem_present?(contents, name)
+      contents.each_line.any? do |line|
+        line.match?(/\A\s*gem\s+["']#{Regexp.escape(name)}["']/)
+      end
     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
     end
 
@@ -179,5 +201,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,14 +10,14 @@ module Smartest
       require 'smartest/rails'
       require "playwright"
 
+      # 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"
+
       class RailsSystemTestFixture < 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"
-
           server = Smartest::Rails::TestServer.new(
             app: Rails.application,
             host: ENV["SMARTEST_RAILS_TEST_SERVER_HOST"],
@@ -118,6 +118,7 @@ module Smartest
 
       require "test_helper"
 
+      # @type [Playwright::Page] page
       test("loads the Rails application") do |page:|
         response = page.goto("/")
 
@@ -198,24 +199,45 @@ module Smartest
       path = File.join(@root, "Gemfile")
       exists = File.exist?(path)
       contents = exists ? File.read(path) : "source \"https://rubygems.org\"\n"
+      updated = contents.dup
 
-      if contents.match?(/gem ["']playwright-ruby-client["']/)
+      unless gem_present?(updated, "smartest")
+        updated = append_gem(updated, 'gem "smartest"')
+      end
+
+      if gem_present?(updated, "playwright-ruby-client")
         @output.puts "exist   Gemfile playwright-ruby-client"
-        return
+      else
+        updated = append_gem(updated, 'gem "playwright-ruby-client", group: :test')
       end
 
+      if updated != contents
+        File.write(path, updated)
+        @output.puts(exists ? "update  Gemfile" : "create  Gemfile")
+      end
+    end
+
+    def append_gem(contents, line)
       separator = contents.end_with?("\n") ? "" : "\n"
-      updated = "#{contents}#{separator}\ngem \"playwright-ruby-client\", group: :test\n"
-      File.write(path, updated)
-      @output.puts(exists ? "update  Gemfile" : "create  Gemfile")
+      "#{contents}#{separator}\n#{line}\n"
+    end
+
+    def gem_present?(contents, name)
+      contents.each_line.any? do |line|
+        line.match?(/\A\s*gem\s+["']#{Regexp.escape(name)}["']/)
+      end
     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
 
       if skip_browser_download?
@@ -238,5 +260,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/version.rb

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

data/sig/smartest.rbs

@@ -0,0 +1,163 @@
+# Smartest public DSL signatures for editors and type-aware tooling.
+
+module Smartest
+  VERSION: String
+
+  def self.suite: () -> Suite
+  def self.reset!: () -> Suite
+  def self.disable_autorun!: () -> true
+  def self.autorun_disabled?: () -> bool
+  def self.register_autorun!: () -> nil
+  def self.install_dsl!: () -> untyped
+  def self.fatal_exception?: (Exception) -> bool
+
+  module DSL
+    private
+
+    # Define a named test. Fixture values are requested from the block with
+    # required keyword arguments, for example `do |page:|`.
+    def test: (String | Symbol, **untyped) { (*untyped, **untyped) -> untyped } -> void
+
+    # Wrap the whole suite. The block receives a run target and must call
+    # `suite.run` exactly once.
+    def around_suite: () { (SuiteRun) -> untyped } -> void
+
+    # Wrap tests registered after this hook in the same file. The block receives
+    # a run target and must call `test.run` exactly once.
+    def around_test: () { (TestRun) -> untyped } -> void
+  end
+
+  module Expectations
+    private
+
+    def expect: (?untyped) ?{ () -> untyped } -> ExpectationTarget
+  end
+
+  module Matchers
+    private
+
+    def eq: (untyped) -> Matcher
+    def include: (untyped) -> Matcher
+    def start_with: (*untyped) -> Matcher
+    def end_with: (*untyped) -> Matcher
+    def be_a: (Class | Module) -> Matcher
+    def be_an: (Class | Module) -> Matcher
+    def be_nil: () -> Matcher
+    def match: (Regexp | String) -> Matcher
+    def contain_exactly: (*untyped) -> Matcher
+    def match_array: (Array[untyped]) -> Matcher
+    def raise_error: (*untyped) -> Matcher
+    def change: () { () -> untyped } -> Matcher
+  end
+
+  module ConstantStubHelpers
+    private
+
+    def with_stub_const: (String | Symbol, untyped) { () -> untyped } -> untyped
+  end
+
+  class Fixture
+    # Define a test-scoped fixture by default. Fixture dependencies are requested
+    # from the block with required keyword arguments.
+    def self.fixture: (String | Symbol, ?scope: Symbol) { (*untyped, **untyped) -> untyped } -> FixtureDefinition
+
+    # Define a suite-scoped fixture shared by all tests in the suite.
+    def self.suite_fixture: (String | Symbol) { (*untyped, **untyped) -> untyped } -> FixtureDefinition
+
+    def self.fixture_definitions: () -> Hash[Symbol, FixtureDefinition]
+
+    private
+
+    def on_teardown: () { () -> untyped } -> untyped
+    def simple_stub_any_instance_of: (Class | Module, String | Symbol) { (*untyped, **untyped) -> untyped } -> SimpleStub
+    def simple_stub: (untyped, String | Symbol) { (*untyped, **untyped) -> untyped } -> SimpleStub
+  end
+
+  class AroundSuiteContext
+    private
+
+    def use_fixture: (Class | Module) -> untyped
+    def use_matcher: (Module) -> untyped
+    def around_test: () { (TestRun) -> untyped } -> void
+    def with_stub_const: (String | Symbol, untyped) { () -> untyped } -> untyped
+  end
+
+  class AroundTestContext
+    private
+
+    def use_fixture: (Class | Module) -> untyped
+    def use_matcher: (Module) -> untyped
+    def use_helper: (Module) -> untyped
+    def skip: (?String) -> void
+    def pending: (?String) -> void
+    def with_stub_const: (String | Symbol, untyped) { () -> untyped } -> untyped
+  end
+
+  class ExecutionContext
+    include Expectations
+    include Matchers
+    include ConstantStubHelpers
+
+    private
+
+    def skip: (?String) -> void
+    def pending: (?String) -> void
+  end
+
+  class SuiteRun
+    attr_reader result: untyped
+
+    def run: () -> untyped
+    def ran?: () -> bool
+  end
+
+  class TestRun
+    attr_reader result: untyped
+
+    def run: () -> untyped
+    def ran?: () -> bool
+  end
+
+  class ExpectationTarget
+    def to: (untyped) -> self
+    def not_to: (untyped) -> self
+  end
+
+  class Matcher
+    def and: (untyped) -> Matcher
+    def or: (untyped) -> Matcher
+    def description: () -> String
+  end
+
+  class FixtureDefinition
+    attr_reader name: Symbol
+    attr_reader block: Proc
+    attr_reader location: Thread::Backtrace::Location?
+    attr_reader scope: Symbol
+    attr_reader dependencies: Array[Symbol]
+  end
+
+  class SimpleStub
+    def apply: () -> self
+    def reset: () -> nil
+  end
+
+  class Suite
+  end
+end
+
+module Kernel
+  private
+
+  # Define a named Smartest test. Fixture values are requested with keyword
+  # block parameters, for example `test("opens page") do |page:|`.
+  def test: (String | Symbol, **untyped) { (*untyped, **untyped) -> untyped } -> void
+
+  # Register a suite hook. The block receives a run target and must call
+  # `suite.run` exactly once.
+  def around_suite: () { (Smartest::SuiteRun) -> untyped } -> void
+
+  # Register a test hook for tests declared after this hook in the same file.
+  # The block receives a run target and must call `test.run` exactly once.
+  def around_test: () { (Smartest::TestRun) -> untyped } -> void
+end

data/smartest/smartest_test.rb

@@ -82,6 +82,12 @@ test("registers fixture classes with use_fixture") do |registered_user_name:|
   expect(registered_user_name).to eq("Alice")
 end
 
+test("gemspec packages RBS signatures") do
+  spec = Gem::Specification.load(File.expand_path("../smartest.gemspec", __dir__))
+
+  expect(spec.files).to include("sig/smartest.rbs")
+end
+
 test("runs a registered test") do
   suite = Smartest::Suite.new
   suite.tests.add(SmartestSelfTest.test_case("factorial", proc { expect(1 * 2 * 3).to eq(6) }))
@@ -2150,6 +2156,7 @@ test("cli browser init generator creates Playwright scaffold and installation co
     expect(status).to eq(0)
     example_browser_test = File.read(File.join(dir, "smartest/example_browser_test.rb"))
     expect(example_browser_test).to include("finds the smartest gem on RubyGems")
+    expect(example_browser_test).to include("# @type [Playwright::Page] page")
     expect(example_browser_test).to include('expect(page).to have_url("https://rubygems.org/gems/smartest")')
     expect(example_browser_test).to include('expect(page.locator("h1")).to have_text("smartest")')
     expect(example_browser_test).not_to include("0.3.0.alpha1")
@@ -2166,6 +2173,8 @@ test("cli browser init generator creates Playwright scaffold and installation co
     expect(helper_contents).to include("use_matcher PredicateMatcher\n  use_fixture PlaywrightFixture\n  use_matcher PlaywrightMatcher\n  suite.run")
 
     gemfile_contents = File.read(File.join(dir, "Gemfile"))
+    expect(gemfile_contents).to include('gem "smartest"')
+    expect(gemfile_contents.scan(/^\s*gem ["']smartest["']/).length).to eq(1)
     expect(gemfile_contents).to include('gem "playwright-ruby-client", group: :test')
     expect(commands).to eq(
       [
@@ -2183,6 +2192,70 @@ test("cli browser init generator creates Playwright scaffold and installation co
   end
 end
 
+test("cli browser init generator keeps smartest in Gemfile when adding Playwright") do
+  Dir.mktmpdir do |dir|
+    File.write(File.join(dir, "Gemfile"), <<~RUBY)
+      source "https://rubygems.org"
+    RUBY
+
+    generator = Smartest::InitBrowserGenerator.new(
+      root: dir,
+      output: StringIO.new,
+      command_runner: ->(_command, chdir:) { true }
+    )
+
+    status = generator.run
+
+    expect(status).to eq(0)
+    gemfile_contents = File.read(File.join(dir, "Gemfile"))
+    expect(gemfile_contents).to include('gem "smartest"')
+    expect(gemfile_contents).to include('gem "playwright-ruby-client", group: :test')
+  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)
@@ -2341,8 +2414,12 @@ test("cli rails init generator creates Rails browser scaffold and installation c
     expect(rails_fixture).to include("require 'smartest/rails'")
     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.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:")
@@ -2376,6 +2453,7 @@ test("cli rails init generator creates Rails browser scaffold and installation c
     expect(rails_fixture).to include("fixture :page do |browser_context:|")
 
     example_test = File.read(File.join(dir, "smartest/example_rails_system_test.rb"))
+    expect(example_test).to include("# @type [Playwright::Page] page")
     expect(example_test).to include('test("loads the Rails application") do |page:|')
     expect(example_test).to include('response = page.goto("/")')
     expect(example_test).to include("expect(response.status).to be_between(200, 599)")
@@ -2385,6 +2463,8 @@ test("cli rails init generator creates Rails browser scaffold and installation c
     expect(helper_contents).not_to include("Smartest::SimpleStub")
 
     gemfile_contents = File.read(File.join(dir, "Gemfile"))
+    expect(gemfile_contents).to include('gem "smartest"')
+    expect(gemfile_contents.scan(/^\s*gem ["']smartest["']/).length).to eq(1)
     expect(gemfile_contents).to include('gem "playwright-ruby-client", group: :test')
     expect(commands).to eq(
       [
@@ -2398,6 +2478,135 @@ 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 keeps smartest in Gemfile when adding Playwright") do
+  Dir.mktmpdir do |dir|
+    File.write(File.join(dir, "Gemfile"), <<~RUBY)
+      source "https://rubygems.org"
+
+      gem "rails"
+    RUBY
+
+    generator = Smartest::InitRailsGenerator.new(
+      root: dir,
+      output: StringIO.new,
+      command_runner: ->(_command, chdir:) { true }
+    )
+
+    status = generator.run
+
+    expect(status).to eq(0)
+    gemfile_contents = File.read(File.join(dir, "Gemfile"))
+    expect(gemfile_contents).to include('gem "smartest"')
+    expect(gemfile_contents).to include('gem "playwright-ruby-client", group: :test')
+  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|

data/smartest.gemspec

@@ -42,6 +42,7 @@ Gem::Specification.new do |spec|
         "SMARTEST_DESIGN.md",
         "exe/*",
         "lib/**/*.rb",
+        "sig/**/*.rbs",
         "smartest.gemspec",
         "smartest/**/*.rb"
       ]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2.alpha1
 platform: ruby
 authors:
 - Yusuke Iwaki
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-09 00:00:00.000000000 Z
+date: 2026-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -78,6 +78,7 @@ files:
 - lib/smartest/test_run.rb
 - lib/smartest/test_run_state.rb
 - lib/smartest/version.rb
+- sig/smartest.rbs
 - smartest.gemspec
 - smartest/simple_stub_test.rb
 - smartest/smartest_test.rb
@@ -103,9 +104,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.19
 signing_key: