smartest 0.3.3.alpha4 → 0.5.0.alpha1

data/lib/smartest/runner.rb

@@ -10,7 +10,7 @@ module Smartest
 
     def run
       results = []
-      suite_cleanup_errors = []
+      suite_teardown_errors = []
       suite_errors = []
       @suite_fixture_set = nil
 
@@ -18,7 +18,7 @@ module Smartest
 
       begin
         run_around_suite_hooks(@suite.around_suite_hooks.dup) do
-          run_tests(results, suite_cleanup_errors)
+          run_tests(results, suite_teardown_errors)
         end
       rescue Exception => error
         raise if Smartest.fatal_exception?(error)
@@ -28,16 +28,16 @@ module Smartest
 
       @reporter.finish(
         results,
-        suite_cleanup_errors: suite_cleanup_errors,
+        suite_teardown_errors: suite_teardown_errors,
         suite_errors: suite_errors
       )
 
-      results.any?(&:failed?) || suite_cleanup_errors.any? || suite_errors.any? ? 1 : 0
+      results.any?(&:failed?) || suite_teardown_errors.any? || suite_errors.any? ? 1 : 0
     end
 
     private
 
-    def run_tests(results, suite_cleanup_errors)
+    def run_tests(results, suite_teardown_errors)
       begin
         @tests.each do |test_case|
           result = run_one(test_case)
@@ -45,7 +45,7 @@ module Smartest
           @reporter.record(result)
         end
       ensure
-        suite_cleanup_errors.concat(@suite_fixture_set.run_cleanups) if @suite_fixture_set
+        suite_teardown_errors.concat(@suite_fixture_set.run_teardowns) if @suite_fixture_set
         @suite_fixture_set = nil
       end
     end
@@ -68,13 +68,13 @@ module Smartest
       started_at = now
       error = nil
       skipped = nil
-      cleanup_errors = []
+      teardown_errors = []
       run_state = TestRunState.new
       test_run = TestRun.new(
         fixture_classes: @suite.fixture_classes,
         matcher_modules: @suite.matcher_modules
       ) do |fixture_classes:, matcher_modules:, helper_modules:|
-        run_test_body(test_case, fixture_classes, matcher_modules, helper_modules, run_state, cleanup_errors)
+        run_test_body(test_case, fixture_classes, matcher_modules, helper_modules, run_state, teardown_errors)
       end
 
       begin
@@ -89,12 +89,12 @@ module Smartest
 
       duration = now - started_at
 
-      return TestResult.failed(test_case: test_case, error: nil, duration: duration, cleanup_errors: cleanup_errors) if skipped && cleanup_errors.any?
+      return TestResult.failed(test_case: test_case, error: nil, duration: duration, teardown_errors: teardown_errors) if skipped && teardown_errors.any?
       return TestResult.skipped(test_case: test_case, reason: skipped.reason, duration: duration) if skipped
 
       if run_state.pending?
         if error && !around_test_protocol_error?(error)
-          return TestResult.failed(test_case: test_case, error: nil, duration: duration, cleanup_errors: cleanup_errors) if cleanup_errors.any?
+          return TestResult.failed(test_case: test_case, error: nil, duration: duration, teardown_errors: teardown_errors) if teardown_errors.any?
 
           return TestResult.pending(test_case: test_case, reason: run_state.pending_reason, duration: duration)
         end
@@ -102,19 +102,19 @@ module Smartest
         error ||= PendingPassedError.new(run_state.pending_reason)
       end
 
-      if error || cleanup_errors.any?
+      if error || teardown_errors.any?
         TestResult.failed(
           test_case: test_case,
           error: error,
           duration: duration,
-          cleanup_errors: cleanup_errors
+          teardown_errors: teardown_errors
         )
       else
         TestResult.passed(test_case: test_case, duration: duration)
       end
     end
 
-    def run_test_body(test_case, fixture_classes, matcher_modules, helper_modules, run_state, cleanup_errors)
+    def run_test_body(test_case, fixture_classes, matcher_modules, helper_modules, run_state, teardown_errors)
       context = build_context(matcher_modules, run_state, helper_modules)
       fixture_set = nil
 
@@ -123,7 +123,7 @@ module Smartest
         fixtures = fixture_set.resolve_keywords(test_case.fixture_names)
         context.instance_exec(**fixtures, &test_case.block)
       ensure
-        cleanup_errors.concat(fixture_set.run_cleanups) if fixture_set
+        teardown_errors.concat(fixture_set.run_teardowns) if fixture_set
       end
     end
 

data/lib/smartest/test_result.rb

@@ -2,59 +2,59 @@
 
 module Smartest
   class TestResult
-    attr_reader :test_case, :status, :error, :duration, :cleanup_errors, :reason
+    attr_reader :test_case, :status, :error, :duration, :teardown_errors, :reason
 
-    def self.passed(test_case:, duration:, cleanup_errors: [])
+    def self.passed(test_case:, duration:, teardown_errors: [])
       new(
         test_case: test_case,
         status: :passed,
         error: nil,
         reason: nil,
         duration: duration,
-        cleanup_errors: cleanup_errors
+        teardown_errors: teardown_errors
       )
     end
 
-    def self.failed(test_case:, error:, duration:, cleanup_errors: [])
+    def self.failed(test_case:, error:, duration:, teardown_errors: [])
       new(
         test_case: test_case,
         status: :failed,
         error: error,
         reason: nil,
         duration: duration,
-        cleanup_errors: cleanup_errors
+        teardown_errors: teardown_errors
       )
     end
 
-    def self.skipped(test_case:, reason:, duration:, cleanup_errors: [])
+    def self.skipped(test_case:, reason:, duration:, teardown_errors: [])
       new(
         test_case: test_case,
         status: :skipped,
         error: nil,
         reason: reason,
         duration: duration,
-        cleanup_errors: cleanup_errors
+        teardown_errors: teardown_errors
       )
     end
 
-    def self.pending(test_case:, reason:, duration:, cleanup_errors: [])
+    def self.pending(test_case:, reason:, duration:, teardown_errors: [])
       new(
         test_case: test_case,
         status: :pending,
         error: nil,
         reason: reason,
         duration: duration,
-        cleanup_errors: cleanup_errors
+        teardown_errors: teardown_errors
       )
     end
 
-    def initialize(test_case:, status:, error:, reason:, duration:, cleanup_errors:)
+    def initialize(test_case:, status:, error:, reason:, duration:, teardown_errors:)
       @test_case = test_case
       @status = status
       @error = error
       @reason = reason
       @duration = duration
-      @cleanup_errors = cleanup_errors
+      @teardown_errors = teardown_errors
     end
 
     def passed?

data/lib/smartest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Smartest
-  VERSION = "0.3.3.alpha4"
+  VERSION = "0.5.0.alpha1"
 end

data/smartest/simple_stub_test.rb

@@ -96,7 +96,7 @@ test("simple stub can be reset from a fresh stub object") do
   expect(SimpleStubSelfTestSubject.new("Alice").greeting("Hi")).to eq("Hi, Alice")
 end
 
-test("simple_stub_any_instance_of applies and resets from fixture cleanup") do
+test("simple_stub_any_instance_of applies and resets from fixture teardown") do
   fixture_class = Class.new(Smartest::Fixture) do
     fixture :stubbed_name do
       simple_stub_any_instance_of(SimpleStubSelfTestSubject, :name) { "fixture #{@name}" }
@@ -127,7 +127,7 @@ test("simple_stub_any_instance_of applies and resets from fixture cleanup") do
   expect(status).to eq(0)
 end
 
-test("simple_stub applies and resets singleton methods from fixture cleanup") do
+test("simple_stub applies and resets singleton methods from fixture teardown") do
   fixture_class = Class.new(Smartest::Fixture) do
     fixture :stubbed_time do
       simple_stub(SimpleStubSelfTestClock, :now) { :stubbed_now }
@@ -158,8 +158,8 @@ test("simple_stub applies and resets singleton methods from fixture cleanup") do
   expect(status).to eq(0)
 end
 
-test("simple_stub_const applies and resets existing constants in test body blocks") do
-  result = simple_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider) do
+test("with_stub_const applies and resets existing constants in test body blocks") do
+  result = with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider) do
     expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:stubbed_provider)
     :block_result
   end
@@ -168,17 +168,17 @@ test("simple_stub_const applies and resets existing constants in test body block
   expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
 end
 
-test("simple_stub_const removes newly defined constants after test body blocks") do
-  simple_stub_const("SimpleStubSelfTestConfig::MISSING_PROVIDER", :stubbed_missing_provider) do
+test("with_stub_const removes newly defined constants after test body blocks") do
+  with_stub_const("SimpleStubSelfTestConfig::MISSING_PROVIDER", :stubbed_missing_provider) do
     expect(SimpleStubSelfTestConfig::MISSING_PROVIDER).to eq(:stubbed_missing_provider)
   end
 
   expect(SimpleStubSelfTestConfig.const_defined?(:MISSING_PROVIDER, false)).to eq(false)
 end
 
-test("simple_stub_const restores constants when the block raises") do
+test("with_stub_const restores constants when the block raises") do
   error = SimpleStubSelfTest.capture_error(RuntimeError) do
-    simple_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider) do
+    with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider) do
       expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:stubbed_provider)
       raise "stubbed block failed"
     end
@@ -188,18 +188,18 @@ test("simple_stub_const restores constants when the block raises") do
   expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
 end
 
-test("simple_stub_const requires a block") do
+test("with_stub_const requires a block") do
   error = SimpleStubSelfTest.capture_error(ArgumentError) do
-    simple_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider)
+    with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider)
   end
 
-  expect(error.message).to eq("simple_stub_const block is required")
+  expect(error.message).to eq("with_stub_const block is required")
 end
 
-test("simple_stub_const wraps around_test hooks") do
+test("with_stub_const wraps around_test hooks") do
   suite = Smartest::Suite.new
   suite.around_test_hooks << proc do |test_run|
-    simple_stub_const("SimpleStubSelfTestConfig::PROVIDER", :around_test_provider) do
+    with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :around_test_provider) do
       test_run.run
     end
   end
@@ -216,10 +216,10 @@ test("simple_stub_const wraps around_test hooks") do
   expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
 end
 
-test("simple_stub_const wraps around_suite hooks") do
+test("with_stub_const wraps around_suite hooks") do
   suite = Smartest::Suite.new
   suite.around_suite_hooks << proc do |suite_run|
-    simple_stub_const("SimpleStubSelfTestConfig::PROVIDER", :around_suite_provider) do
+    with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :around_suite_provider) do
       suite_run.run
     end
   end
@@ -236,10 +236,10 @@ test("simple_stub_const wraps around_suite hooks") do
   expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
 end
 
-test("simple_stub_const is not available inside fixture blocks") do
+test("with_stub_const is not available inside fixture blocks") do
   fixture_class = Class.new(Smartest::Fixture) do
     fixture :bad_constant_stub do
-      simple_stub_const("SimpleStubSelfTestConfig::PROVIDER", :fixture_provider) { :fixture_provider }
+      with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :fixture_provider) { :fixture_provider }
     end
   end
 
@@ -251,7 +251,7 @@ test("simple_stub_const is not available inside fixture blocks") do
 
   expect(status).to eq(1)
   expect(output).to include("NoMethodError")
-  expect(output).to include("simple_stub_const")
+  expect(output).to include("with_stub_const")
   expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
 end
 

data/smartest/smartest_test.rb

@@ -697,7 +697,7 @@ test("caches fixture values within one test") do
   expect(calls).to eq(1)
 end
 
-test("suite fixtures are created once and cleaned up after the suite") do
+test("suite fixtures are created once and torn down after the suite") do
   events = []
   servers = []
 
@@ -705,7 +705,7 @@ test("suite fixtures are created once and cleaned up after the suite") do
     suite_fixture :server do
       events << :server_setup
       server = Object.new
-      cleanup { events << :server_cleanup }
+      on_teardown { events << :server_teardown }
       server
     end
   end
@@ -718,7 +718,7 @@ test("suite fixtures are created once and cleaned up after the suite") do
   status, = SmartestSelfTest.run_suite(suite)
 
   expect(status).to eq(0)
-  expect(events).to eq(%i[server_setup first second server_cleanup])
+  expect(events).to eq(%i[server_setup first second server_teardown])
   expect(servers.length).to eq(2)
   expect(servers[0].object_id).to eq(servers[1].object_id)
 end
@@ -773,14 +773,14 @@ test("suite fixtures cannot depend on test fixtures") do
   expect(output).to include("suite-scoped fixture server cannot depend on test-scoped fixture user")
 end
 
-test("suite fixture setup failures are cached and cleaned up once") do
+test("suite fixture setup failures are cached and torn down once") do
   calls = 0
   events = []
 
   fixture_class = Class.new(Smartest::Fixture) do
     suite_fixture :server do
       calls += 1
-      cleanup { events << :server_cleanup }
+      on_teardown { events << :server_teardown }
       raise "server setup failed"
     end
   end
@@ -794,17 +794,17 @@ test("suite fixture setup failures are cached and cleaned up once") do
 
   expect(status).to eq(1)
   expect(calls).to eq(1)
-  expect(events).to eq([:server_cleanup])
+  expect(events).to eq([:server_teardown])
   expect(output.scan("RuntimeError: server setup failed").length).to eq(2)
 end
 
-test("around_suite wraps tests and suite fixture cleanup") do
+test("around_suite wraps tests and suite fixture teardown") do
   events = []
 
   fixture_class = Class.new(Smartest::Fixture) do
     suite_fixture :server do
       events << :server_setup
-      cleanup { events << :server_cleanup }
+      on_teardown { events << :server_teardown }
       :server
     end
   end
@@ -821,7 +821,7 @@ test("around_suite wraps tests and suite fixture cleanup") do
   status, = SmartestSelfTest.run_suite(suite)
 
   expect(status).to eq(0)
-  expect(events).to eq(%i[around_before server_setup test server_cleanup around_after])
+  expect(events).to eq(%i[around_before server_setup test server_teardown around_after])
 end
 
 test("around_suite hooks run in registration order") do
@@ -886,13 +886,13 @@ test("around_suite can register suite-wide around_test hooks") do
   expect(events).to eq(%i[around_test_before test around_test_after])
 end
 
-test("around_test wraps fixture setup, test body, and cleanup") do
+test("around_test wraps fixture setup, test body, and teardown") do
   events = []
 
   fixture_class = Class.new(Smartest::Fixture) do
     fixture :resource do
       events << :fixture_setup
-      cleanup { events << :fixture_cleanup }
+      on_teardown { events << :fixture_teardown }
       :resource
     end
   end
@@ -918,7 +918,7 @@ test("around_test wraps fixture setup, test body, and cleanup") do
   status, = SmartestSelfTest.run_suite(suite)
 
   expect(status).to eq(0)
-  expect(events).to eq(%i[around_test_before fixture_setup test fixture_cleanup around_test_after])
+  expect(events).to eq(%i[around_test_before fixture_setup test fixture_teardown around_test_after])
 end
 
 test("around_test can register fixtures for one test run") do
@@ -1232,10 +1232,10 @@ test("around_suite must call suite.run") do
   expect(output).to include("Smartest::AroundSuiteRunError: around_suite hook did not call suite.run")
 end
 
-test("suite cleanup failures fail the run") do
+test("suite teardown failures fail the run") do
   fixture_class = Class.new(Smartest::Fixture) do
     suite_fixture :browser do
-      cleanup { raise "browser close failed" }
+      on_teardown { raise "browser close failed" }
       :browser
     end
   end
@@ -1247,22 +1247,22 @@ test("suite cleanup failures fail the run") do
   status, output = SmartestSelfTest.run_suite(suite)
 
   expect(status).to eq(1)
-  expect(output).to include("Suite cleanup failures:")
-  expect(output).to include("cleanup failed: RuntimeError: browser close failed")
-  expect(output).to include("1 test, 1 passed, 0 failed, 1 suite cleanup failed")
+  expect(output).to include("Suite teardown failures:")
+  expect(output).to include("teardown failed: RuntimeError: browser close failed")
+  expect(output).to include("1 test, 1 passed, 0 failed, 1 suite teardown failed")
 end
 
-test("runs cleanup in reverse order after failures") do
+test("runs teardown in reverse order after failures") do
   events = []
 
   fixture_class = Class.new(Smartest::Fixture) do
     fixture :server do
-      cleanup { events << :server }
+      on_teardown { events << :server }
       :server
     end
 
     fixture :browser do |server:|
-      cleanup { events << :browser }
+      on_teardown { events << :browser }
       server
     end
   end
@@ -1277,12 +1277,12 @@ test("runs cleanup in reverse order after failures") do
   expect(events).to eq(%i[browser server])
 end
 
-test("runs cleanup when fixture setup fails after cleanup registration") do
+test("runs teardown when fixture setup fails after teardown registration") do
   events = []
 
   fixture_class = Class.new(Smartest::Fixture) do
     fixture :server do
-      cleanup { events << :server }
+      on_teardown { events << :server }
       raise "server setup failed"
     end
   end
@@ -1298,6 +1298,25 @@ test("runs cleanup when fixture setup fails after cleanup registration") do
   expect(output).to include("RuntimeError: server setup failed")
 end
 
+test("does not keep cleanup as a fixture teardown alias") do
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :server do
+      cleanup { :server }
+      :server
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("needs server", proc { |server:| expect(server).to eq(:server) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("NoMethodError")
+  expect(output).to include("cleanup")
+end
+
 test("duplicate fixture names fail the test") do
   first_fixture = Class.new(Smartest::Fixture) do
     fixture(:user) { "Alice" }
@@ -1435,6 +1454,44 @@ test("cli loads files and returns failure status") do
   end
 end
 
+test("cli expands directory paths to tests under that directory") do
+  Dir.mktmpdir do |dir|
+    smartest_dir = File.join(dir, "smartest")
+    FileUtils.mkdir_p(File.join(smartest_dir, "nested"))
+    File.write(File.join(smartest_dir, "test_helper.rb"), <<~RUBY)
+      require "smartest/autorun"
+    RUBY
+    File.write(File.join(smartest_dir, "root_test.rb"), <<~RUBY)
+      require "test_helper"
+
+      test("root directory test") do
+        expect(1).to eq(1)
+      end
+    RUBY
+    File.write(File.join(smartest_dir, "nested", "nested_test.rb"), <<~RUBY)
+      require "test_helper"
+
+      test("nested directory test") do
+        expect(2).to eq(2)
+      end
+    RUBY
+
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      "smartest/",
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(true)
+    expect(stderr).to eq("")
+    expect(stdout).to include("root directory test")
+    expect(stdout).to include("nested directory test")
+    expect(stdout).to include("2 tests, 2 passed, 0 failed")
+  end
+end
+
 test("cli loads matcher files registered in test helper") do
   Dir.mktmpdir do |dir|
     smartest_dir = File.join(dir, "smartest")
@@ -1656,14 +1713,61 @@ test("cli prints help") do
   expect(status.success?).to eq(true)
   expect(stderr).to eq("")
   expect(stdout).to include("Usage:")
-  expect(stdout).to include("smartest [--profile N] [paths...]")
-  expect(stdout).to include("smartest [--profile N] path/to/test_file.rb:line[-line]")
-  expect(stdout).to include("smartest --init")
-  expect(stdout).to include("smartest --init-browser")
-  expect(stdout).to include("Use --profile N")
+  expect(stdout).to include("bundle exec smartest [options] [paths...]")
+  expect(stdout).to include("Common commands:")
+  expect(stdout).to include("bundle exec smartest smartest/suite1/")
+  expect(stdout).to include("Run test files matching smartest/suite1/**/*_test.rb")
+  expect(stdout).to include("bundle exec smartest smartest/user_test.rb")
+  expect(stdout).to include("bundle exec smartest smartest/user_test.rb:12")
+  expect(stdout).not_to include("bundle exec smartest smartest/example_browser_test.rb")
+  expect(stdout).not_to include("Run a browser test file")
+  expect(stdout).to include("bundle exec smartest --init")
+  expect(stdout).to include("bundle exec smartest --init-browser")
+  expect(stdout).to include("--profile N")
   expect(stdout).to include("smartest/**/*_test.rb")
 end
 
+test("cli explains how to initialize when default smartest directory is missing") do
+  Dir.mktmpdir do |dir|
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(false)
+    expect(stderr).to eq("")
+    expect(stdout).to include("No smartest/ directory found.")
+    expect(stdout).to include("bundle exec smartest --init")
+    expect(stdout).to include("bundle exec smartest --init-browser")
+    expect(stdout).to include("bundle exec smartest --help")
+  end
+end
+
+test("cli still runs explicit paths when default smartest directory is missing") do
+  Dir.mktmpdir do |dir|
+    File.write(File.join(dir, "sample_test.rb"), <<~RUBY)
+      test("explicit path") do
+        expect(1).to eq(1)
+      end
+    RUBY
+
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      "sample_test.rb",
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(true)
+    expect(stderr).to eq("")
+    expect(stdout).to include("explicit path")
+    expect(stdout).to include("1 test, 1 passed, 0 failed")
+  end
+end
+
 test("--profile prints the slowest tests with default count of 5") do
   output = StringIO.new
   reporter = Smartest::Reporter.new(output, profile_count: 5)
@@ -1760,7 +1864,9 @@ test("CLIArguments defaults profile count and parses --profile N") do
 
   expect(arguments.profile_count).to eq(5)
   expect(arguments.files).to eq(Dir["smartest/**/*_test.rb"])
+  expect(arguments.default_paths?).to eq(true)
   expect(Smartest::CLIArguments.new(["--profile", "3"]).profile_count).to eq(3)
+  expect(Smartest::CLIArguments.new(["smartest/foo_test.rb"]).default_paths?).to eq(false)
 end
 
 test("CLIArguments leaves unsupported profile forms as paths") do

data/smartest.gemspec

@@ -7,8 +7,15 @@ Gem::Specification.new do |spec|
   spec.version = Smartest::VERSION
   spec.authors = ["Yusuke Iwaki"]
 
-  spec.summary = "Pytest-style fixtures for Ruby."
-  spec.description = "Smartest is a Ruby test runner with pytest-style fixture injection. Tests request fixtures using keyword arguments, fixtures can depend on other fixtures, and cleanup is registered only when needed."
+  spec.summary = "A Ruby test runner with pytest-style fixtures and Playwright-friendly browser testing."
+  spec.description = <<~TEXT
+    Smartest is a Ruby test runner that brings pytest-style fixture injection
+    to Ruby. Tests declare dependencies with keyword arguments, fixtures can
+    depend on other fixtures, and teardown is handled explicitly when needed.
+
+    Smartest is designed for readable Ruby tests, Rails system tests, and
+    Playwright-powered browser testing.
+  TEXT
   spec.homepage = "https://smartest-rb.vercel.app"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.7"
@@ -17,7 +24,7 @@ Gem::Specification.new do |spec|
     "allowed_push_host" => "https://rubygems.org",
     "bug_tracker_uri" => "https://github.com/YusukeIwaki/smartest/issues",
     "changelog_uri" => "https://github.com/YusukeIwaki/smartest/blob/main/CHANGELOG.md",
-    "documentation_uri" => "https://smartest-rb.vercel.app/docs/fixtures",
+    "documentation_uri" => "https://smartest-rb.vercel.app/docs",
     "homepage_uri" => spec.homepage,
     "rubygems_mfa_required" => "true",
     "source_code_uri" => "https://github.com/YusukeIwaki/smartest"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.3.3.alpha4
+  version: 0.5.0.alpha1
 platform: ruby
 authors:
 - Yusuke Iwaki
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-04 00:00:00.000000000 Z
+date: 2026-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -24,9 +24,13 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: Smartest is a Ruby test runner with pytest-style fixture injection. Tests
-  request fixtures using keyword arguments, fixtures can depend on other fixtures,
-  and cleanup is registered only when needed.
+description: |
+  Smartest is a Ruby test runner that brings pytest-style fixture injection
+  to Ruby. Tests declare dependencies with keyword arguments, fixtures can
+  depend on other fixtures, and teardown is handled explicitly when needed.
+
+  Smartest is designed for readable Ruby tests, Rails system tests, and
+  Playwright-powered browser testing.
 email:
 executables:
 - smartest
@@ -82,7 +86,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   bug_tracker_uri: https://github.com/YusukeIwaki/smartest/issues
   changelog_uri: https://github.com/YusukeIwaki/smartest/blob/main/CHANGELOG.md
-  documentation_uri: https://smartest-rb.vercel.app/docs/fixtures
+  documentation_uri: https://smartest-rb.vercel.app/docs
   homepage_uri: https://smartest-rb.vercel.app
   rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/YusukeIwaki/smartest
@@ -104,5 +108,6 @@ requirements: []
 rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
-summary: Pytest-style fixtures for Ruby.
+summary: A Ruby test runner with pytest-style fixtures and Playwright-friendly browser
+  testing.
 test_files: []