smartest 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d2b5aeaf51e6e6878eac74601d634daab2e423cede641216856a79188c28554
-  data.tar.gz: 4f90e558f84062585a0a8b3596c91f9507f9fec09430a86c6782ae7a3ba92bb7
+  metadata.gz: e192221b36307c61da97572a41e866b137f1a668bb9db26bda75fbd6489df89a
+  data.tar.gz: eb3ee1b6ffae15eaf27b88ffbe4d01bfedbb763a7a1d52bb99bae34bd7e8dc97
 SHA512:
-  metadata.gz: 687150dcb8a16d475d76b9840fecf63b7705fc0b5e123380d6ffe3fe415a77ed89228bdbc098e66db22d67164f4b43412229e47311be15b6ab09643bf00aa43f
-  data.tar.gz: 037f50862bd76bcb86e4511227a8a5f2ce943e37fdce3d823124ff90872efa1a808bb7eee4a2ab9c0985c685baf2db451c304074e6797f88d1c2f370390adea6
+  metadata.gz: 916737afbb7af9447c571d16de7c08e73ea52686462a2b99c4378a118e38d613fdbe3152f13fbf089fd518b8930c3e8f927451678e58e23777150a3d98158608
+  data.tar.gz: fe618761cbe53ad37bde38182018835b7566d7a205d0edd92c7e43547d002b131771bce65f2f82a66b7dc3afa770c190d3d8ccfd4e374398e0e2341aa22baf98

data/CHANGELOG.md

@@ -1,19 +1,24 @@
 # Changelog
 
-## 0.1.0 - Unreleased
-
-- Add the initial Smartest test runner.
-- Support top-level `test` definitions.
-- Support class-based fixtures through `Smartest::Fixture`.
-- Support required keyword-argument fixture injection and fixture dependencies.
-- Support per-test fixture caching and cleanup.
-- Support suite-scoped fixtures through `suite_fixture`.
-- Support `eq`, `include`, `start_with`, `end_with`, `be_nil`, `raise_error`, and `change` matchers.
-- Support custom matcher modules through `use_matcher`.
-- Generate an opt-in `PredicateMatcher` custom matcher for `be_<predicate>` calls.
-- Add the `smartest` CLI.
-- Add `--help` and `--version` CLI options.
-- Use `smartest/**/*_test.rb` as the default CLI glob so Smartest can coexist with Minitest files under `test/`.
-- Add gem packaging metadata and release tasks.
-- Add Docusaurus documentation.
-- Add `smartest --init-browser` with a Playwright init scaffold, fixture setup, matcher generation, and dependency installation.
+## 0.5.0
+
+### Breaking Changes
+
+- Rename the fixture teardown registration API from `cleanup` to
+  `on_teardown`. The old `cleanup` method is no longer available.
+- Rename teardown failure output from cleanup terminology to teardown
+  terminology.
+
+## 0.4.0
+
+### New Features
+
+- Add fixture-scoped method stub helpers: `simple_stub_any_instance_of` and
+  `simple_stub`.
+- Add `with_stub_const` for block-scoped constant stubbing in test bodies,
+  `around_test`, and `around_suite`.
+- Support Ruby 2.7 and newer.
+
+## 0.1.0 - 0.3.2
+
+- Initial release.

data/DEVELOPMENT.md

@@ -13,7 +13,7 @@ Smartest is a Ruby test runner focused on:
 - top-level test definitions
 - class-based fixtures
 - explicit keyword-argument fixture dependencies
-- optional cleanup for fixtures that need teardown
+- optional teardown for fixtures that need teardown
 - suite-scoped fixtures for expensive shared resources
 - a small internal architecture that is easy to reason about
 
@@ -224,7 +224,7 @@ Responsibilities:
 - class-level `suite_fixture` DSL for suite-scoped fixtures
 - stores fixture definitions
 - supports inheritance
-- exposes `cleanup` to fixture blocks
+- exposes `on_teardown` to fixture blocks
 - optionally delegates helper methods to `ExecutionContext`
 - does not delegate `skip` or `pending` to fixture blocks
 
@@ -293,8 +293,8 @@ Responsibilities:
 - find fixture definitions
 - resolve fixture dependencies
 - cache fixture values for its scope
-- collect cleanup blocks
-- run cleanup blocks in reverse order
+- collect teardown blocks
+- run teardown blocks in reverse order
 - detect duplicate fixture names
 - detect circular dependencies
 
@@ -332,9 +332,9 @@ Responsibilities:
 - create a fresh `FixtureSet` per test
 - resolve test keyword fixtures
 - run test body
-- run cleanup in `ensure`
+- run teardown in `ensure`
 - track skipped and pending test state
-- run suite fixture cleanup after all tests
+- run suite fixture teardown after all tests
 - produce `TestResult`
 - notify reporter
 
@@ -373,7 +373,7 @@ rescue Exception => error
     TestResult.failed(test_case, error)
   end
 ensure
-  fixture_set&.run_cleanups
+  fixture_set&.run_teardowns
 end
 ```
 
@@ -424,7 +424,7 @@ end
 
 fixture :server do
   server = TestServer.start
-  cleanup { server.stop }
+  on_teardown { server.stop }
   server
 end
 
@@ -456,12 +456,12 @@ resolve :logged_in_client
   evaluate logged_in_client
   cache logged_in_client
 run test body
-run cleanup stack
+run teardown stack
 ```
 
-## Cleanup behavior
+## Teardown behavior
 
-Fixture cleanup is optional.
+Fixture teardown is optional.
 
 Fixture without teardown:
 
@@ -476,33 +476,33 @@ Fixture with teardown:
 ```ruby
 fixture :server do
   server = TestServer.start
-  cleanup { server.stop }
+  on_teardown { server.stop }
 
   server.wait_until_ready!
   server
 end
 ```
 
-`cleanup` should register a block on the current fixture set. Regular fixture
-cleanups run after the test. `suite_fixture` cleanups run after all tests.
+`on_teardown` should register a block on the current fixture set. Regular fixture
+teardown blocks run after the test. `suite_fixture` teardown blocks run after all tests.
 
-Cleanup blocks must run:
+Teardown blocks must run:
 
 - after the test body
 - after the suite for suite-scoped fixtures
 - after failed tests
-- after fixture setup errors, if cleanup was already registered
+- after fixture setup errors, if teardown was already registered
 - in reverse registration order
 
 Implementation:
 
 ```ruby
-def add_cleanup(&block)
-  @cleanups << block
+def add_teardown(&block)
+  @teardowns << block
 end
 
-def run_cleanups
-  @cleanups.reverse_each(&:call)
+def run_teardowns
+  @teardowns.reverse_each(&:call)
 end
 ```
 
@@ -621,17 +621,17 @@ A practical approach:
 - recursive fixture resolution
 - per-test caching
 
-### Phase 4: Cleanup
+### Phase 4: Teardown
 
-- `cleanup { ... }`
-- cleanup stack on `FixtureSet`
-- cleanup in `ensure`
+- `on_teardown { ... }`
+- teardown stack on `FixtureSet`
+- teardown in `ensure`
 
 ### Phase 5: Suite-scoped fixtures
 
 - `suite_fixture :name do ... end`
 - suite-level fixture cache
-- suite cleanup after all tests
+- suite teardown after all tests
 - test fixtures may depend on suite fixtures
 - suite fixtures may not depend on test fixtures
 
@@ -662,14 +662,14 @@ A practical approach:
 
 - `around_suite do |suite| ... end`
 - run hooks around the full suite body
-- include suite fixture cleanup inside the wrapped body
+- include suite fixture teardown inside the wrapped body
 - report hook failures as suite failures
 
 ### Phase 8: Test hooks
 
 - `around_test do |test| ... end`
 - snapshot file-local hooks when each test is registered
-- run hooks around fixture setup, test body, and fixture cleanup
+- run hooks around fixture setup, test body, and fixture teardown
 - expose `use_fixture` and `use_matcher` only inside hook contexts
 - make `around_test` registered from `around_suite` suite-wide
 
@@ -720,7 +720,7 @@ end
 ```
 
 ```ruby
-cleanup { ... }
+on_teardown { ... }
 ```
 
 ```ruby
@@ -843,6 +843,22 @@ Before releasing:
 - run a sample project against the installed gem
 - push the release tag
 
+### Changelog updates
+
+Update `CHANGELOG.md` from the actual diff between released versions, not from
+commit messages. For an already tagged release, compare the previous release tag
+to the release tag and inspect the code/docs changes, for example:
+
+```bash
+git diff --stat 0.4.0..0.5.0
+git diff 0.4.0..0.5.0
+```
+
+Before the new tag exists, compare the latest release tag to the release branch
+or working tree and inspect the same kind of diff. Only document breaking
+changes and notable new features. Do not copy every commit message or list
+documentation-only maintenance changes unless they materially affect users.
+
 Example commands:
 
 ```bash

data/README.md

@@ -1,7 +1,10 @@
-# Smartest introduces Pytest-style fixtures for Ruby
+# Smartest
 
-Smartest is a small Ruby test runner that brings pytest-style fixture
-injection, explicit fixture dependencies, and fixture cleanup to Ruby tests.
+[![Gem Version](https://badge.fury.io/rb/smartest.svg)](https://rubygems.org/gems/smartest)
+
+Smartest is a Ruby test runner that brings pytest-style fixtures to Ruby,
+with explicit fixture dependencies, automatic teardown, and Playwright-friendly
+browser testing.
 
 Tests request fixtures with Ruby keyword arguments. Fixtures define their own
 dependencies the same way:
@@ -10,7 +13,7 @@ dependencies the same way:
 class WebFixture < Smartest::Fixture
   fixture :server do
     server = TestServer.start
-    cleanup { server.stop }
+    on_teardown { server.stop }
     server
   end
 
@@ -45,7 +48,7 @@ idea: tests should explicitly declare their dependencies.
 RSpec `let` is useful when examples need lazy helper methods. Minitest `setup`
 is simple for xUnit-style setup. Rails fixtures and FactoryBot are great for
 test data. Smartest is aimed at tests where setup resources, dependency graphs,
-and cleanup should be visible in the test signature and fixture definitions.
+and teardown should be visible in the test signature and fixture definitions.
 
 ```ruby
 test("GET /me") do |logged_in_client:|
@@ -67,6 +70,9 @@ end
 
 Smartest requires Ruby 2.7 or newer.
 
+Smartest is published as the `smartest` RubyGem:
+[Smartest on RubyGems](https://rubygems.org/gems/smartest).
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -477,7 +483,7 @@ released after the full suite finishes:
 class BrowserFixture < Smartest::Fixture
   suite_fixture :browser do
     browser = Browser.launch
-    cleanup { browser.close }
+    on_teardown { browser.close }
     browser
   end
 
@@ -488,7 +494,7 @@ end
 ```
 
 Suite fixtures are lazy: setup runs the first time a test requests the fixture,
-and cleanup runs once after all tests finish. Test-scoped fixtures can depend on
+and teardown runs once after all tests finish. Test-scoped fixtures can depend on
 suite fixtures, but suite fixtures cannot depend on test-scoped fixtures.
 
 ## Suite hooks
@@ -504,8 +510,8 @@ end
 ```
 
 The hook receives a run target and must call `suite.run` exactly once. The block
-wraps every test, test-scoped fixture setup and cleanup, suite fixture setup, and
-suite fixture cleanup.
+wraps every test, test-scoped fixture setup and teardown, suite fixture setup, and
+suite fixture teardown.
 
 Fixture and matcher registrations made before `suite.run` are applied to that
 run:
@@ -546,7 +552,7 @@ end
 ```
 
 The hook receives a run target and must call `test.run` exactly once. It wraps
-fixture setup, the test body, and fixture cleanup.
+fixture setup, the test body, and fixture teardown.
 
 `around_test` is file-scoped when it is written directly in a test file. Smartest
 copies the current file's `around_test` hooks when each `test` is registered, so
@@ -580,20 +586,20 @@ end
 
 Fixture classes registered from `around_test` must define only test-scoped
 fixtures. If a class defines `suite_fixture`, register it from `around_suite`
-instead so its cache and cleanup belong to the suite lifecycle.
+instead so its cache and teardown belong to the suite lifecycle.
 
 `use_fixture` and `use_matcher` are only available inside `around_suite` or
 `around_test` blocks. They are not top-level DSL methods.
 
 ## Fixtures with teardown
 
-Not every fixture needs teardown. For fixtures that do, use `cleanup`.
+Not every fixture needs teardown. For fixtures that do, use `on_teardown`.
 
 ```ruby
 class WebFixture < Smartest::Fixture
   fixture :server do
     server = TestServer.start
-    cleanup { server.stop }
+    on_teardown { server.stop }
 
     server.wait_until_ready!
     server
@@ -605,8 +611,8 @@ class WebFixture < Smartest::Fixture
 end
 ```
 
-`cleanup` blocks run after the fixture's scope finishes. For regular fixtures
-that means after the test. For `suite_fixture`, cleanup runs after the full
+`on_teardown` blocks run after the fixture's scope finishes. For regular fixtures
+that means after the test. For `suite_fixture`, teardown runs after the full
 suite.
 
 They are executed in reverse order of registration.
@@ -614,7 +620,7 @@ They are executed in reverse order of registration.
 ```ruby
 fixture :temp_dir do
   dir = Dir.mktmpdir
-  cleanup { FileUtils.rm_rf(dir) }
+  on_teardown { FileUtils.rm_rf(dir) }
 
   dir
 end
@@ -625,19 +631,19 @@ Recommended pattern:
 ```ruby
 fixture :server do
   server = TestServer.start
-  cleanup { server.stop }
+  on_teardown { server.stop }
 
   server.wait_until_ready!
   server
 end
 ```
 
-Register cleanup immediately after acquiring the resource, before later setup steps that may fail.
+Register teardown immediately after acquiring the resource, before later setup steps that may fail.
 
 ## Stubs
 
 Use simple stub helpers when a fixture needs to temporarily replace a Ruby
-method and reset it during cleanup:
+method and reset it during teardown:
 
 ```ruby
 class PaymentFixture < Smartest::Fixture
@@ -678,7 +684,7 @@ constants in test bodies, `around_test`, or `around_suite`. Constant stubs are
 process-global; avoid concurrent tests that stub the same constant.
 
 The method stub helpers call `Smartest::SimpleStub` internally, apply the stub,
-register `cleanup { stub.reset }`, and return the stub object.
+register `on_teardown { stub.reset }`, and return the stub object.
 `with_stub_const` records the previous constant value, replaces it, yields to
 the block, and restores or removes the constant with `ensure`.
 
@@ -695,7 +701,7 @@ the current Fiber, and `reset!` raises
 class WebFixture < Smartest::Fixture
   fixture :server do
     server = TestServer.start
-    cleanup { server.stop }
+    on_teardown { server.stop }
 
     server.wait_until_ready!
     server
@@ -755,7 +761,7 @@ client setup
 user setup
 logged_in_client setup
 test body
-server cleanup
+server teardown
 ```
 
 ## Registering fixture classes
@@ -784,15 +790,15 @@ Fixture names must be unique across registered fixture classes.
 
 If two fixture classes define the same fixture name, Smartest raises an error.
 
-## Suite hooks and fixture cleanup
+## Suite hooks and fixture teardown
 
-Suite hooks are separate from fixture cleanup. Use fixture cleanup for
+Suite hooks are separate from fixture teardown. Use fixture teardown for
 resource-specific teardown:
 
 ```ruby
 fixture :server do
   server = TestServer.start
-  cleanup { server.stop }
+  on_teardown { server.stop }
   server
 end
 ```
@@ -849,7 +855,7 @@ Example:
 class WebFixture < Smartest::Fixture
   fixture :server do
     server = TestServer.start
-    cleanup { server.stop }
+    on_teardown { server.stop }
     server
   end
 
@@ -912,7 +918,7 @@ Smartest currently focuses on a small runner API:
 - class-based fixtures
 - keyword-argument fixture injection
 - fixture dependencies through keyword arguments
-- fixture cleanup
+- fixture teardown
 - suite-scoped fixtures through `suite_fixture`
 - fixture-scoped method stubs and block-scoped constant stubs
 - suite hooks with `around_suite`

data/SMARTEST_DESIGN.md

@@ -30,7 +30,7 @@ Fixture definitions:
 class WebFixture < Smartest::Fixture
   fixture :server do
     server = TestServer.start
-    cleanup { server.stop }
+    on_teardown { server.stop }
 
     server.wait_until_ready!
     server
@@ -195,12 +195,12 @@ server teardown
 
 This is especially complex when fixtures depend on other fixtures.
 
-Smartest instead chooses `cleanup` for the MVP:
+Smartest instead chooses `on_teardown` for the MVP:
 
 ```ruby
 fixture :server do
   server = TestServer.start
-  cleanup { server.stop }
+  on_teardown { server.stop }
 
   server.wait_until_ready!
   server
@@ -214,7 +214,7 @@ This has several advantages:
 - teardown is local to the fixture that owns the resource
 - implementation is simple
 - fixture dependencies remain ordinary recursive resolution
-- cleanup runs in `ensure`
+- teardown runs in `ensure`
 
 Not every fixture needs teardown, so teardown should not shape the entire fixture API.
 
@@ -236,12 +236,12 @@ fixture :article do |user:|
 end
 ```
 
-A fixture may register cleanup.
+A fixture may register teardown.
 
 ```ruby
 fixture :temp_dir do
   dir = Dir.mktmpdir
-  cleanup { FileUtils.rm_rf(dir) }
+  on_teardown { FileUtils.rm_rf(dir) }
   dir
 end
 ```
@@ -316,7 +316,7 @@ Runner
   ├── creates FixtureSet
   ├── resolves keyword fixtures
   ├── executes test body
-  ├── runs cleanup
+  ├── runs teardown
   └── reports TestResult
 ```
 
@@ -343,7 +343,7 @@ end
 
 fixture :server do
   server = TestServer.start
-  cleanup { server.stop }
+  on_teardown { server.stop }
   server
 end
 
@@ -363,7 +363,7 @@ resolve logged_in_client
       requires server
         resolve server
           evaluate server block
-          register cleanup
+          register teardown
           cache server
       evaluate client block with server:
       cache client
@@ -376,7 +376,7 @@ resolve logged_in_client
 
 execute test body with logged_in_client:
 
-run cleanup stack in reverse order
+run teardown stack in reverse order
 ```
 
 ## Fixture caching
@@ -397,33 +397,33 @@ shared for the runner lifetime.
 This keeps regular fixtures isolated while allowing explicit suite fixtures for
 expensive shared resources.
 
-## Cleanup stack
+## Teardown stack
 
-`FixtureSet` owns a cleanup stack for one fixture scope.
+`FixtureSet` owns a teardown stack for one fixture scope.
 
 ```ruby
-@cleanups = []
+@teardowns = []
 ```
 
 Fixture blocks can call:
 
 ```ruby
-cleanup { resource.close }
+on_teardown { resource.close }
 ```
 
 This delegates to:
 
 ```ruby
-fixture_set.add_cleanup(&block)
+fixture_set.add_teardown(&block)
 ```
 
-For test-scoped fixtures, cleanup runs after the test in reverse order:
+For test-scoped fixtures, teardown runs after the test in reverse order:
 
 ```ruby
-@cleanups.reverse_each(&:call)
+@teardowns.reverse_each(&:call)
 ```
 
-For suite-scoped fixtures, cleanup runs after all tests. Reverse order matters
+For suite-scoped fixtures, teardown runs after all tests. Reverse order matters
 because later resources may depend on earlier ones.
 
 Example:
@@ -431,18 +431,18 @@ Example:
 ```ruby
 fixture :server do
   server = TestServer.start
-  cleanup { server.stop }
+  on_teardown { server.stop }
   server
 end
 
 fixture :browser do |server:|
   browser = Browser.launch(server.url)
-  cleanup { browser.close }
+  on_teardown { browser.close }
   browser
 end
 ```
 
-Cleanup should run:
+Teardown should run:
 
 ```text
 browser.close
@@ -669,7 +669,7 @@ Fixture block execution happens on the fixture instance:
 fixture_instance.instance_exec(**dependencies, &definition.block)
 ```
 
-This allows fixture helper methods and `cleanup` to be private instance methods.
+This allows fixture helper methods and `on_teardown` to be private instance methods.
 
 ## Helper methods in fixtures
 
@@ -964,7 +964,7 @@ end
 ```
 
 `around_suite` wraps the full suite body, including all tests and suite fixture
-cleanup. The hook receives a run target and must call `suite.run` exactly once.
+teardown. The hook receives a run target and must call `suite.run` exactly once.
 Multiple hooks compose in registration order, with the first hook as the
 outermost wrapper.
 
@@ -1013,7 +1013,7 @@ For `around_test`, those registrations are test-run local and must happen before
 `test.run`.
 
 Fixture classes registered from `around_test` must not define `suite_fixture`.
-Suite-scoped fixtures need suite-level cache and cleanup ownership, so classes
+Suite-scoped fixtures need suite-level cache and teardown ownership, so classes
 with suite-scoped fixtures must be registered from `around_suite`.
 
 Potential simpler per-test API:
@@ -1036,7 +1036,7 @@ Order:
 before hooks
 fixture setup
 test body
-fixture cleanup
+fixture teardown
 after hooks
 ```
 
@@ -1047,12 +1047,12 @@ fixture setup
 before hooks
 test body
 after hooks
-fixture cleanup
+fixture teardown
 ```
 
 This needs a final decision later.
 
-Fixture cleanup already handles resource-specific teardown.
+Fixture teardown already handles resource-specific teardown.
 
 ### Around-test parallelism note
 
@@ -1086,7 +1086,7 @@ Expensive shared resources can use `suite_fixture`:
 ```ruby
 suite_fixture :server do
   server = TestServer.start
-  cleanup { server.stop }
+  on_teardown { server.stop }
   server
 end
 ```
@@ -1099,7 +1099,7 @@ Supported scopes:
 `fixture :name do ... end` creates a test-scoped fixture.
 
 `suite_fixture :name do ... end` creates a suite-scoped fixture. It is lazy:
-setup runs the first time a test requests it, and cleanup runs after all tests.
+setup runs the first time a test requests it, and teardown runs after all tests.
 
 Test-scoped fixtures may depend on suite-scoped fixtures. Suite-scoped fixtures
 may depend only on other suite-scoped fixtures.
@@ -1136,7 +1136,7 @@ Benefits:
 - reusable fixture modules
 - clearer organization
 - fewer global definitions
-- natural place for cleanup helper
+- natural place for teardown helper
 
 Example:
 
@@ -1197,7 +1197,7 @@ Pros:
 - easy dependency extraction
 - easy duplicate detection
 - easy source locations
-- easy cleanup integration
+- easy teardown integration
 
 ### `fixture def user`
 
@@ -1241,7 +1241,7 @@ Reason:
 
 - requires around-chain execution
 - complicates dependency handling
-- not needed if `cleanup` exists
+- not needed if `on_teardown` exists
 - makes fixture API more complex
 
 Could be added later as advanced API.
@@ -1271,7 +1271,7 @@ class AppFixture < Smartest::Fixture
 
   fixture :server do
     server = TestServer.start
-    cleanup { server.stop }
+    on_teardown { server.stop }
     server
   end
 

data/lib/smartest/fixture.rb

@@ -59,10 +59,10 @@ module Smartest
 
     private
 
-    def cleanup(&block)
-      raise ArgumentError, "cleanup block is required" unless block
+    def on_teardown(&block)
+      raise ArgumentError, "on_teardown block is required" unless block
 
-      @fixture_set.add_cleanup(&block)
+      @fixture_set.add_teardown(&block)
     end
 
     def simple_stub_any_instance_of(klass, method_name, &block)
@@ -75,7 +75,7 @@ module Smartest
 
     def apply_simple_stub(stub)
       stub.apply!
-      cleanup { stub.reset }
+      on_teardown { stub.reset }
       stub
     end
 

data/lib/smartest/fixture_set.rb

@@ -9,7 +9,7 @@ module Smartest
       @parent = parent
       @cache = {}
       @setup_errors = {}
-      @cleanups = []
+      @teardowns = []
       @resolving = []
 
       build_fixture_index
@@ -49,17 +49,17 @@ module Smartest
       @resolving.pop if @resolving.last == symbol_name
     end
 
-    def add_cleanup(&block)
-      raise ArgumentError, "cleanup block is required" unless block
+    def add_teardown(&block)
+      raise ArgumentError, "on_teardown block is required" unless block
 
-      @cleanups << block
+      @teardowns << block
     end
 
-    def run_cleanups
+    def run_teardowns
       errors = []
 
-      @cleanups.reverse_each do |cleanup|
-        cleanup.call
+      @teardowns.reverse_each do |teardown|
+        teardown.call
       rescue Exception => error
         raise if Smartest.fatal_exception?(error)
 

data/lib/smartest/init_browser_generator.rb

@@ -14,7 +14,7 @@ module Smartest
           runtime = Playwright.create(
             playwright_cli_executable_path: "./node_modules/.bin/playwright",
           )
-          cleanup { runtime.stop }
+          on_teardown { runtime.stop }
           runtime.playwright
         end
 
@@ -35,13 +35,13 @@ module Smartest
           end
 
           browser = playwright.send(browser_type).launch(**launch_options)
-          cleanup { browser.close }
+          on_teardown { browser.close }
           browser
         end
 
         fixture :page do |browser:|
           context = browser.new_context
-          cleanup { context.close }
+          on_teardown { context.close }
           context.new_page
         end
       end

data/lib/smartest/reporter.rb

@@ -21,14 +21,14 @@ module Smartest
       @io.puts record_line(result)
     end
 
-    def finish(results, suite_cleanup_errors: [], suite_errors: [])
+    def finish(results, suite_teardown_errors: [], suite_errors: [])
       failures = results.select(&:failed?)
       skipped = results.select(&:skipped?)
       pending = results.select(&:pending?)
 
       report_failures(failures) if failures.any?
       report_suite_errors(suite_errors) if suite_errors.any?
-      report_suite_cleanup_errors(suite_cleanup_errors) if suite_cleanup_errors.any?
+      report_suite_teardown_errors(suite_teardown_errors) if suite_teardown_errors.any?
       report_profile(results) if @profile_count && @profile_count.positive?
 
       @io.puts
@@ -39,9 +39,9 @@ module Smartest
         suite_label = suite_errors.count == 1 ? "suite failure" : "suite failures"
         summary = "#{summary}, #{suite_errors.count} #{suite_label}"
       end
-      if suite_cleanup_errors.any?
-        cleanup_label = suite_cleanup_errors.count == 1 ? "suite cleanup" : "suite cleanups"
-        summary = "#{summary}, #{suite_cleanup_errors.count} #{cleanup_label} failed"
+      if suite_teardown_errors.any?
+        teardown_label = suite_teardown_errors.count == 1 ? "suite teardown" : "suite teardowns"
+        summary = "#{summary}, #{suite_teardown_errors.count} #{teardown_label} failed"
       end
       @io.puts summary
     end
@@ -72,7 +72,7 @@ module Smartest
         @io.puts "#{index + 1}) #{result.test_case.name}"
         report_location(result.test_case.location)
         report_error(result.error) if result.error
-        result.cleanup_errors.each { |error| report_cleanup_error(error) }
+        result.teardown_errors.each { |error| report_teardown_error(error) }
         @io.puts
       end
     end
@@ -89,14 +89,14 @@ module Smartest
       end
     end
 
-    def report_suite_cleanup_errors(errors)
+    def report_suite_teardown_errors(errors)
       @io.puts
-      @io.puts "Suite cleanup failures:"
+      @io.puts "Suite teardown failures:"
       @io.puts
 
       errors.each_with_index do |error, index|
-        @io.puts "#{index + 1}) suite cleanup"
-        report_cleanup_error(error)
+        @io.puts "#{index + 1}) suite teardown"
+        report_teardown_error(error)
         @io.puts
       end
     end
@@ -148,8 +148,8 @@ module Smartest
       report_backtrace(error)
     end
 
-    def report_cleanup_error(error)
-      @io.puts "   cleanup failed: #{error.class}: #{error.message}"
+    def report_teardown_error(error)
+      @io.puts "   teardown failed: #{error.class}: #{error.message}"
       report_backtrace(error)
     end
 

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.4.0"
+  VERSION = "0.5.0"
 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 }

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" }

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.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Yusuke Iwaki
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-06 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: []