smartest 0.2.0.alpha1 → 0.2.0.alpha3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee5c1b7be401fa3dc4a8d88a25a241fc2b0bad486e8a3163a83c6c2340ae7c3c
-  data.tar.gz: f063204cd31bcd99b4654c26bb8591d566dcd424a2a312d9a7c9cbbea4292b01
+  metadata.gz: 17a325d82883047881ac13538f95b3af038e361668869860034acc530ce2e398
+  data.tar.gz: 19c6a1a345e7e0fd02a12ae007a48f38c1be264debd3b23b0b6085d687a867bf
 SHA512:
-  metadata.gz: 18f117d867c86f47ff3d517729c0e7cbae4af5933b7432fa96ad30b1aea58a76b48e7ae4d3c129e72594598d19297751513d49501e5481c9ef07259a5350dafb
-  data.tar.gz: '085a5a10a7d5248d7888fd6267edae7c4dd88077f5b413d45385d4c05245b0eae771975ab67a50befc8ca14d8acb3d148d9718d94b431caf9800d2a2daa78627'
+  metadata.gz: 5b4aeb31472fca3b0911dfb29d4034405f493ac37e3019888a67f1c13c0b1f4aac99dc33b87c7e79a8d363b7bf12f7682b97bea396ebc56b558b592a7658eee9
+  data.tar.gz: 4e1c0cc3b739b62af8c4eeef394662f8115e35f890cdde87ce32117eca26c4064b627a08a2ca204c856276d2a603de8c4c55e2f9c71d2f68c44fd864e13c2ecc

data/CHANGELOG.md

@@ -8,7 +8,7 @@
 - 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`, `be_nil`, and `raise_error` matchers.
+- 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.

data/DEVELOPMENT.md

@@ -224,6 +224,7 @@ Responsibilities:
 - supports inheritance
 - exposes `cleanup` to fixture blocks
 - optionally delegates helper methods to `ExecutionContext`
+- does not delegate `skip` or `pending` to fixture blocks
 
 Fixture definitions should not execute at declaration time.
 
@@ -306,6 +307,7 @@ Responsibilities:
 
 - include expectation methods
 - include matchers
+- expose `skip` and `pending` to test bodies
 - expose helper methods
 - optionally provide integration helpers later
 
@@ -329,6 +331,7 @@ Responsibilities:
 - resolve test keyword fixtures
 - run test body
 - run cleanup in `ensure`
+- track skipped and pending test state
 - run suite fixture cleanup after all tests
 - produce `TestResult`
 - notify reporter
@@ -342,7 +345,8 @@ Pseudo-code:
 
 ```ruby
 def run_one(test_case)
-  context = ExecutionContext.new
+  run_state = TestRunState.new
+  context = ExecutionContext.new(run_state: run_state)
   fixture_set = FixtureSet.new(
     @fixture_classes,
     context: context,
@@ -353,9 +357,19 @@ def run_one(test_case)
 
   context.instance_exec(**kwargs, &test_case.block)
 
-  TestResult.passed(test_case)
+  if run_state.pending?
+    TestResult.failed(test_case, PendingPassedError.new(run_state.pending_reason))
+  else
+    TestResult.passed(test_case)
+  end
+rescue Skipped => skipped
+  TestResult.skipped(test_case, skipped.reason)
 rescue Exception => error
-  TestResult.failed(test_case, error)
+  if run_state.pending?
+    TestResult.pending(test_case, run_state.pending_reason)
+  else
+    TestResult.failed(test_case, error)
+  end
 ensure
   fixture_set&.run_cleanups
 end
@@ -370,13 +384,15 @@ Fields:
 - test case
 - status
 - error
+- reason
 - duration
 
 Statuses:
 
 - passed
 - failed
-- skipped, later
+- skipped
+- pending
 
 ### `Smartest::Reporter`
 
@@ -385,7 +401,7 @@ Console reporter for MVP.
 Responsibilities:
 
 - print run start
-- print per-test pass/fail
+- print per-test pass/fail/skip/pending
 - print failure details
 - print summary
 - return appropriate exit status through runner
@@ -565,6 +581,8 @@ module Smartest
   class CircularFixtureDependencyError < Error; end
   class InvalidFixtureParameterError < Error; end
   class AssertionFailed < Error; end
+  class Skipped < Error; end
+  class PendingPassedError < AssertionFailed; end
 end
 ```
 
@@ -649,6 +667,15 @@ A practical approach:
 - expose `use_fixture` and `use_matcher` only inside hook contexts
 - make `around_test` registered from `around_suite` suite-wide
 
+### Phase 9: Skipped and pending tests
+
+- `skip "reason"` inside test bodies and `around_test` hooks
+- `pending "reason"` inside test bodies and `around_test` hooks
+- skipped tests do not fail the run
+- pending tests pass only when the remaining execution fails
+- pending tests fail with `Smartest::PendingPassedError` when they pass
+- `skip` and `pending` are not `test` metadata
+
 ## MVP API rules
 
 Supported:
@@ -658,6 +685,19 @@ test("name") do
 end
 ```
 
+```ruby
+test("name") do
+  skip "reason" if runtime_condition?
+end
+```
+
+```ruby
+test("name") do
+  pending "reason" if expected_to_fail?
+  expect(actual).to eq(expected)
+end
+```
+
 ```ruby
 test("name") do |user:|
 end
@@ -685,6 +725,7 @@ end
 
 ```ruby
 around_test do |test|
+  pending "reason" if expected_to_fail?
   test.run
 end
 ```
@@ -706,6 +747,16 @@ fixture :client, with: [:server] do |server|
 end
 ```
 
+```ruby
+test("name", skip: true) do
+end
+```
+
+```ruby
+test("name", pending: true) do
+end
+```
+
 ```ruby
 resource :server do |use|
 end

data/README.md

@@ -143,6 +143,34 @@ end
 
 This makes fixture usage explicit and avoids relying on positional argument order.
 
+## Skipping and pending tests
+
+Use `skip` at the start of a test when the rest of the body should not run:
+
+```ruby
+test("PDF export") do |browser:|
+  skip "firefox is not supported" if browser.firefox?
+
+  export_pdf(browser)
+end
+```
+
+Use `pending` when the test should continue running but is expected to fail. If
+the test passes after `pending`, Smartest fails it so the stale pending marker is
+removed.
+
+```ruby
+test("PDF export") do |browser:|
+  pending "Not supported by WebDriver BiDi yet" if browser.bidi?
+
+  export_pdf(browser)
+end
+```
+
+`skip` and `pending` are available in test bodies and `around_test` hooks, but
+not as `test` metadata or fixture APIs. See
+[Skipping Tests](documentation/docs/skipping-tests.md).
+
 ## Expectations
 
 Smartest uses an expectation style:
@@ -150,6 +178,8 @@ Smartest uses an expectation style:
 ```ruby
 expect(actual).to eq(expected)
 expect(actual).not_to eq(expected)
+expect { action }.to raise_error(ErrorClass)
+expect { action }.to change { value }
 ```
 
 Examples:
@@ -162,6 +192,14 @@ end
 test("array") do
   expect([1, 2, 3]).to include(2)
 end
+
+test("URL") do
+  expect("about:blank").to start_with("about:")
+end
+
+test("download") do
+  expect("screenshot.png").to end_with(".png")
+end
 ```
 
 Supported matchers include:
@@ -169,10 +207,18 @@ Supported matchers include:
 ```ruby
 eq(expected)
 include(expected)
+start_with(prefix, ...)
+end_with(suffix, ...)
 be_nil
 raise_error(ErrorClass)
+change { value }
+change { value }.from(before).to(after)
+change { value }.by(delta)
 ```
 
+`change` is only supported with `expect { ... }` block expectations and must be
+written with a value block.
+
 Custom matcher modules can be registered from `around_suite` or `around_test`
 with `use_matcher`. The generated scaffold includes a `PredicateMatcher` custom
 matcher for `be_<predicate>` calls. See [Matchers](documentation/docs/matchers.md).
@@ -648,6 +694,7 @@ The intended MVP includes:
 - fixture cleanup
 - suite hooks with `around_suite`
 - test hooks with `around_test`
+- skipped and pending tests through `skip` and `pending`
 - `expect(...).to eq(...)`
 - console reporter
 - CLI runner

data/SMARTEST_DESIGN.md

@@ -299,7 +299,8 @@ This keeps the top-level DSL small.
 
 Only `test`, `around_suite`, and `around_test` should be globally available when
 using `smartest/autorun`. `use_fixture` and `use_matcher` are available only
-inside hook execution contexts.
+inside hook execution contexts. `skip` and `pending` are available only inside
+test bodies and `around_test` hook execution contexts.
 
 ## Core architecture
 
@@ -691,6 +692,8 @@ end
 Fixture blocks can call private methods because they execute with `instance_exec`.
 
 Fixture classes may optionally delegate missing methods to the execution context.
+They should not delegate `skip` or `pending`; those are test-body and
+`around_test` controls, not fixture APIs.
 
 This is useful for integration helpers.
 
@@ -714,6 +717,19 @@ MVP expectation API:
 ```ruby
 expect(actual).to eq(expected)
 expect(actual).not_to eq(expected)
+expect { action }.to change { value }
+```
+
+Current built-in matchers include:
+
+```ruby
+eq(expected)
+include(expected)
+start_with(prefix, ...)
+end_with(suffix, ...)
+be_nil
+raise_error(ErrorClass)
+change { value }
 ```
 
 Internal model:
@@ -831,28 +847,38 @@ Care must be taken not to run twice if both CLI and autorun are used.
 
 ## Exit status
 
-- all tests passed: `0`
+- all tests passed, skipped, or pending as expected: `0`
 - any test failed: `1`
+- pending test unexpectedly passed: `1`
 - configuration/load error: `1`
 - interrupted: re-raise or exit non-zero
 
 ## Metadata
 
-`test` should accept metadata:
+`test` accepts metadata and stores it on `TestCase`, but metadata does not drive
+runner behavior in the MVP:
 
 ```ruby
-test("name", skip: true) do
-end
-
 test("name", tags: [:db]) do
 end
 ```
 
-MVP can store metadata without implementing all behavior.
+Runtime skipping and pending behavior are method calls inside the test body or
+`around_test`, not metadata:
+
+```ruby
+test("name") do
+  skip "reason" if runtime_condition?
+end
+
+test("name") do
+  pending "reason" if expected_to_fail?
+  expect(actual).to eq(expected)
+end
+```
 
 Useful metadata later:
 
-- `skip: true`
 - `only: true`
 - `tags: [:db]`
 - `timeout: 5`
@@ -1198,18 +1224,30 @@ test("GET /health") do |client:|
 end
 ```
 
+```ruby
+test("PDF export") do |browser:|
+  skip "firefox is not supported" if browser.firefox?
+
+  export_pdf(browser)
+end
+
+test("PDF export over BiDi") do |browser:|
+  pending "Not supported by WebDriver BiDi yet" if browser.bidi?
+
+  export_pdf(browser)
+  expect(browser.downloads).not_to be_empty
+end
+```
+
 ## Future ideas
 
 Possible future features:
 
-- `skip`
 - `only`
 - tags
 - custom reporters
 - JSON output
 - richer matchers
-- block expectations
-- `raise_error`
 - file-scoped fixtures
 - parallel execution
 - watch mode

data/lib/smartest/errors.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 
 module Smartest
+  module StatusReason
+    DEFAULT_REASON = "No reason given"
+
+    def self.normalize(reason)
+      text = reason.to_s
+      text.empty? ? DEFAULT_REASON : text
+    end
+  end
+
   class Error < StandardError; end
 
   class FixtureNotFoundError < Error
@@ -65,4 +74,19 @@ module Smartest
   class AroundTestRunError < Error; end
 
   class AssertionFailed < Error; end
+
+  class Skipped < Error
+    attr_reader :reason
+
+    def initialize(reason = nil)
+      @reason = StatusReason.normalize(reason)
+      super(@reason)
+    end
+  end
+
+  class PendingPassedError < AssertionFailed
+    def initialize(reason = nil)
+      super("expected pending test to fail, but it passed: #{StatusReason.normalize(reason)}")
+    end
+  end
 end

data/lib/smartest/execution_context.rb

@@ -4,5 +4,19 @@ module Smartest
   class ExecutionContext
     include Expectations
     include Matchers
+
+    def initialize(run_state: TestRunState.new)
+      @run_state = run_state
+    end
+
+    private
+
+    def skip(reason = nil)
+      raise Skipped, reason
+    end
+
+    def pending(reason = nil)
+      @run_state.pending(reason)
+    end
   end
 end

data/lib/smartest/expectation_target.rb

@@ -13,6 +13,12 @@ module Smartest
     end
 
     def not_to(matcher)
+      if matcher.respond_to?(:does_not_match?)
+        return self if matcher.does_not_match?(@actual)
+
+        raise AssertionFailed, matcher.negated_failure_message
+      end
+
       return self unless matcher.matches?(@actual)
 
       raise AssertionFailed, matcher.negated_failure_message

data/lib/smartest/fixture.rb

@@ -2,6 +2,8 @@
 
 module Smartest
   class Fixture
+    RESERVED_CONTEXT_METHODS = %i[skip pending].freeze
+
     class << self
       def fixture(name, scope: :test, &block)
         define_fixture(
@@ -64,6 +66,8 @@ module Smartest
     end
 
     def method_missing(method_name, *args, &block)
+      return super if RESERVED_CONTEXT_METHODS.include?(method_name)
+
       if @context.respond_to?(method_name, true)
         @context.__send__(method_name, *args, &block)
       else
@@ -72,6 +76,8 @@ module Smartest
     end
 
     def respond_to_missing?(method_name, include_private = false)
+      return super if RESERVED_CONTEXT_METHODS.include?(method_name)
+
       @context.respond_to?(method_name, true) || super
     end
   end

data/lib/smartest/hook_contexts.rb

@@ -30,8 +30,9 @@ module Smartest
   end
 
   class AroundTestContext
-    def initialize(test_run)
+    def initialize(test_run, run_state:)
       @test_run = test_run
+      @run_state = run_state
     end
 
     def call(hook, run_target = @test_run)
@@ -47,5 +48,13 @@ module Smartest
     def use_matcher(matcher_module)
       @test_run.add_matcher_module(matcher_module)
     end
+
+    def skip(reason = nil)
+      raise Skipped, reason
+    end
+
+    def pending(reason = nil)
+      @run_state.pending(reason)
+    end
   end
 end

data/lib/smartest/matchers.rb

@@ -10,6 +10,14 @@ module Smartest
       IncludeMatcher.new(expected)
     end
 
+    def start_with(*prefixes)
+      StartWithMatcher.new(*prefixes)
+    end
+
+    def end_with(*suffixes)
+      EndWithMatcher.new(*suffixes)
+    end
+
     def be_nil
       BeNilMatcher.new
     end
@@ -17,6 +25,13 @@ module Smartest
     def raise_error(expected_error = StandardError)
       RaiseErrorMatcher.new(expected_error)
     end
+
+    def change(*args, &block)
+      raise ArgumentError, "change does not support arguments; use change { ... }" if args.any?
+      raise ArgumentError, "change requires a block" unless block
+
+      ChangeMatcher.new(block)
+    end
   end
 
   class EqMatcher
@@ -59,6 +74,64 @@ module Smartest
     end
   end
 
+  class StartWithMatcher
+    def initialize(*prefixes)
+      @prefixes = prefixes
+    end
+
+    def matches?(actual)
+      @actual = actual
+      actual.start_with?(*@prefixes)
+    rescue NoMethodError
+      false
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to start with #{expected_description}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to start with #{expected_description}"
+    end
+
+    private
+
+    def expected_description
+      return "no prefixes" if @prefixes.empty?
+
+      @prefixes.map(&:inspect).join(" or ")
+    end
+  end
+
+  class EndWithMatcher
+    def initialize(*suffixes)
+      @suffixes = suffixes
+    end
+
+    def matches?(actual)
+      @actual = actual
+      actual.end_with?(*@suffixes)
+    rescue NoMethodError
+      false
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to end with #{expected_description}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to end with #{expected_description}"
+    end
+
+    private
+
+    def expected_description
+      return "no suffixes" if @suffixes.empty?
+
+      @suffixes.map(&:inspect).join(" or ")
+    end
+  end
+
   class BeNilMatcher
     def matches?(actual)
       @actual = actual
@@ -106,4 +179,140 @@ module Smartest
       "expected block not to raise #{@expected_error}, but raised #{@actual_error.class}: #{@actual_error.message}"
     end
   end
+
+  class ChangeMatcher
+    UNSET = Object.new
+
+    def initialize(value_block)
+      @value_block = value_block
+      @expected_from = UNSET
+      @expected_to = UNSET
+      @expected_delta = UNSET
+      reset_result
+    end
+
+    def from(expected)
+      @expected_from = expected
+      self
+    end
+
+    def to(expected)
+      @expected_to = expected
+      self
+    end
+
+    def by(expected_delta)
+      @expected_delta = expected_delta
+      self
+    end
+
+    def matches?(actual)
+      run_change(actual)
+      return false unless @callable
+
+      positive_failures.empty?
+    end
+
+    def does_not_match?(actual)
+      run_change(actual)
+      return false unless @callable
+
+      negated_failures.empty?
+    end
+
+    def failure_message
+      return "expected a block to change value" unless @callable
+
+      "expected value to #{expected_description}, but #{observed_description}#{failed_modifier_description}"
+    end
+
+    def negated_failure_message
+      return "expected a block not to change value" unless @callable
+
+      "expected value not to change, but #{observed_description}"
+    end
+
+    private
+
+    def reset_result
+      @callable = true
+      @before_value = nil
+      @after_value = nil
+      @actual_delta = UNSET
+      @failed_modifiers = []
+    end
+
+    def run_change(actual)
+      reset_result
+      @callable = actual.respond_to?(:call)
+      return unless @callable
+
+      @before_value = @value_block.call
+      actual.call
+      @after_value = @value_block.call
+      calculate_delta if delta_expected?
+    end
+
+    def positive_failures
+      @failed_modifiers = []
+      @failed_modifiers << "change" if !delta_expected? && @before_value == @after_value
+      @failed_modifiers << "from(#{@expected_from.inspect})" if from_expected? && @before_value != @expected_from
+      @failed_modifiers << "to(#{@expected_to.inspect})" if to_expected? && @after_value != @expected_to
+      @failed_modifiers << "by(#{@expected_delta.inspect})" if delta_expected? && @actual_delta != @expected_delta
+      @failed_modifiers
+    end
+
+    def negated_failures
+      @failed_modifiers = []
+      @failed_modifiers << "change" unless @before_value == @after_value
+      @failed_modifiers
+    end
+
+    def expected_description
+      parts = ["change"]
+      parts << "from #{@expected_from.inspect}" if from_expected?
+      parts << "to #{@expected_to.inspect}" if to_expected?
+      parts << "by #{@expected_delta.inspect}" if delta_expected?
+      parts.join(" ")
+    end
+
+    def observed_description
+      if delta_expected?
+        delta_description = if @actual_delta.equal?(UNSET)
+                              "could not calculate a numeric difference"
+                            else
+                              "changed by #{@actual_delta.inspect}"
+                            end
+
+        "#{delta_description} from #{@before_value.inspect} before to #{@after_value.inspect} after"
+      else
+        "was #{@before_value.inspect} before and #{@after_value.inspect} after"
+      end
+    end
+
+    def failed_modifier_description
+      failures = positive_failures
+      return "" if failures.empty?
+
+      "; failed modifiers: #{failures.join(', ')}"
+    end
+
+    def calculate_delta
+      @actual_delta = @after_value - @before_value
+    rescue NoMethodError, TypeError
+      @actual_delta = UNSET
+    end
+
+    def from_expected?
+      !@expected_from.equal?(UNSET)
+    end
+
+    def to_expected?
+      !@expected_to.equal?(UNSET)
+    end
+
+    def delta_expected?
+      !@expected_delta.equal?(UNSET)
+    end
+  end
 end

data/lib/smartest/reporter.rb

@@ -4,6 +4,8 @@ module Smartest
   class Reporter
     PASS_MARK = "\u2713"
     FAIL_MARK = "\u2717"
+    SKIP_MARK = "-"
+    PENDING_MARK = "*"
 
     def initialize(io = $stdout)
       @io = io
@@ -15,12 +17,13 @@ module Smartest
     end
 
     def record(result)
-      mark = result.passed? ? PASS_MARK : FAIL_MARK
-      @io.puts "#{mark} #{result.test_case.name}"
+      @io.puts record_line(result)
     end
 
     def finish(results, suite_cleanup_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?
@@ -28,6 +31,8 @@ module Smartest
 
       @io.puts
       summary = "#{results.count} #{results.count == 1 ? 'test' : 'tests'}, #{results.count(&:passed?)} passed, #{failures.count} failed"
+      summary = "#{summary}, #{skipped.count} skipped" if skipped.any?
+      summary = "#{summary}, #{pending.count} pending" if pending.any?
       if suite_errors.any?
         suite_label = suite_errors.count == 1 ? "suite failure" : "suite failures"
         summary = "#{summary}, #{suite_errors.count} #{suite_label}"
@@ -41,6 +46,21 @@ module Smartest
 
     private
 
+    def record_line(result)
+      case result.status
+      when :passed
+        "#{PASS_MARK} #{result.test_case.name}"
+      when :failed
+        "#{FAIL_MARK} #{result.test_case.name}"
+      when :skipped
+        "#{SKIP_MARK} #{result.test_case.name} (skipped: #{result.reason})"
+      when :pending
+        "#{PENDING_MARK} #{result.test_case.name} (pending: #{result.reason})"
+      else
+        "#{FAIL_MARK} #{result.test_case.name}"
+      end
+    end
+
     def report_failures(failures)
       @io.puts
       @io.puts "Failures:"

data/lib/smartest/runner.rb

@@ -67,16 +67,20 @@ module Smartest
     def run_one(test_case)
       started_at = now
       error = nil
+      skipped = nil
       cleanup_errors = []
+      run_state = TestRunState.new
       test_run = TestRun.new(
         fixture_classes: @suite.fixture_classes,
         matcher_modules: @suite.matcher_modules
       ) do |fixture_classes:, matcher_modules:|
-        cleanup_errors = run_test_body(test_case, fixture_classes, matcher_modules)
+        run_test_body(test_case, fixture_classes, matcher_modules, run_state, cleanup_errors)
       end
 
       begin
-        run_around_test_hooks(@suite.around_test_hooks + test_case.around_test_hooks, test_run)
+        run_around_test_hooks(@suite.around_test_hooks + test_case.around_test_hooks, test_run, run_state)
+      rescue Skipped => skipped_error
+        skipped = skipped_error
       rescue Exception => rescued_error
         raise if Smartest.fatal_exception?(rescued_error)
 
@@ -85,6 +89,19 @@ 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.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.pending(test_case: test_case, reason: run_state.pending_reason, duration: duration)
+        end
+
+        error ||= PendingPassedError.new(run_state.pending_reason)
+      end
+
       if error || cleanup_errors.any?
         TestResult.failed(
           test_case: test_case,
@@ -97,23 +114,20 @@ module Smartest
       end
     end
 
-    def run_test_body(test_case, fixture_classes, matcher_modules)
-      context = build_context(matcher_modules)
+    def run_test_body(test_case, fixture_classes, matcher_modules, run_state, cleanup_errors)
+      context = build_context(matcher_modules, run_state)
       fixture_set = nil
-      cleanup_errors = []
 
       begin
         fixture_set = FixtureSet.new(fixture_classes, context: context, parent: suite_fixture_set)
         fixtures = fixture_set.resolve_keywords(test_case.fixture_names)
         context.instance_exec(**fixtures, &test_case.block)
       ensure
-        cleanup_errors = fixture_set.run_cleanups if fixture_set
+        cleanup_errors.concat(fixture_set.run_cleanups) if fixture_set
       end
-
-      cleanup_errors
     end
 
-    def run_around_test_hooks(hooks, test_run, index = 0)
+    def run_around_test_hooks(hooks, test_run, run_state, index = 0)
       return test_run.run if index >= hooks.length
 
       hook = hooks[index]
@@ -121,10 +135,10 @@ module Smartest
         fixture_classes: [],
         matcher_modules: []
       ) do |**_keywords|
-        run_around_test_hooks(hooks, test_run, index + 1)
+        run_around_test_hooks(hooks, test_run, run_state, index + 1)
       end
 
-      AroundTestContext.new(test_run).call(hook, next_run)
+      AroundTestContext.new(test_run, run_state: run_state).call(hook, next_run)
       raise AroundTestRunError, "around_test hook did not call test.run" unless next_run.ran?
 
       next_run.result
@@ -138,12 +152,16 @@ module Smartest
       )
     end
 
-    def build_context(matcher_modules = @suite.matcher_modules)
-      ExecutionContext.new.tap do |context|
+    def build_context(matcher_modules = @suite.matcher_modules, run_state = TestRunState.new)
+      ExecutionContext.new(run_state: run_state).tap do |context|
         matcher_modules.each { |matcher_module| context.extend(matcher_module) }
       end
     end
 
+    def around_test_protocol_error?(error)
+      error.is_a?(AroundTestRunError)
+    end
+
     def now
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end

data/lib/smartest/test_result.rb

@@ -2,13 +2,14 @@
 
 module Smartest
   class TestResult
-    attr_reader :test_case, :status, :error, :duration, :cleanup_errors
+    attr_reader :test_case, :status, :error, :duration, :cleanup_errors, :reason
 
     def self.passed(test_case:, duration:, cleanup_errors: [])
       new(
         test_case: test_case,
         status: :passed,
         error: nil,
+        reason: nil,
         duration: duration,
         cleanup_errors: cleanup_errors
       )
@@ -19,15 +20,39 @@ module Smartest
         test_case: test_case,
         status: :failed,
         error: error,
+        reason: nil,
         duration: duration,
         cleanup_errors: cleanup_errors
       )
     end
 
-    def initialize(test_case:, status:, error:, duration:, cleanup_errors:)
+    def self.skipped(test_case:, reason:, duration:, cleanup_errors: [])
+      new(
+        test_case: test_case,
+        status: :skipped,
+        error: nil,
+        reason: reason,
+        duration: duration,
+        cleanup_errors: cleanup_errors
+      )
+    end
+
+    def self.pending(test_case:, reason:, duration:, cleanup_errors: [])
+      new(
+        test_case: test_case,
+        status: :pending,
+        error: nil,
+        reason: reason,
+        duration: duration,
+        cleanup_errors: cleanup_errors
+      )
+    end
+
+    def initialize(test_case:, status:, error:, reason:, duration:, cleanup_errors:)
       @test_case = test_case
       @status = status
       @error = error
+      @reason = reason
       @duration = duration
       @cleanup_errors = cleanup_errors
     end
@@ -39,5 +64,13 @@ module Smartest
     def failed?
       status == :failed
     end
+
+    def skipped?
+      status == :skipped
+    end
+
+    def pending?
+      status == :pending
+    end
   end
 end

data/lib/smartest/test_run_state.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Smartest
+  class TestRunState
+    attr_reader :pending_reason
+
+    def pending(reason = nil)
+      @pending_reason = StatusReason.normalize(reason)
+      nil
+    end
+
+    def pending?
+      !@pending_reason.nil?
+    end
+  end
+end

data/lib/smartest/version.rb

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

data/lib/smartest.rb

@@ -12,6 +12,7 @@ require_relative "smartest/matcher_registry"
 require_relative "smartest/fixture_set"
 require_relative "smartest/suite"
 require_relative "smartest/suite_run"
+require_relative "smartest/test_run_state"
 require_relative "smartest/test_run"
 require_relative "smartest/hook_contexts"
 require_relative "smartest/expectations"

data/smartest/smartest_test.rb

@@ -79,6 +79,92 @@ test("reports expectation failures") do
   expect(output).to include("1 test, 0 passed, 1 failed")
 end
 
+test("skip marks a test as skipped and stops the body") do
+  events = []
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "unsupported export",
+      proc do
+        events << :before_skip
+        skip "firefox is not supported"
+        events << :after_skip
+      end
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(events).to eq([:before_skip])
+  expect(output).to include("- unsupported export (skipped: firefox is not supported)")
+  expect(output).to include("1 test, 0 passed, 0 failed, 1 skipped")
+  expect(output).not_to include("Failures:")
+end
+
+test("pending marks a failing test as pending") do
+  events = []
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bidi export",
+      proc do
+        pending "Not supported by WebDriver BiDi yet"
+        events << :after_pending
+        expect("actual").to eq("expected")
+        events << :after_failure
+      end
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(events).to eq([:after_pending])
+  expect(output).to include("* bidi export (pending: Not supported by WebDriver BiDi yet)")
+  expect(output).to include("1 test, 0 passed, 0 failed, 1 pending")
+  expect(output).not_to include("Failures:")
+end
+
+test("pending fails when the test passes") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "fixed bidi export",
+      proc do
+        pending "Not supported by WebDriver BiDi yet"
+        expect("actual").to eq("actual")
+      end
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("expected pending test to fail, but it passed: Not supported by WebDriver BiDi yet")
+  expect(output).to include("1 test, 0 passed, 1 failed")
+end
+
+test("skip and pending are not available inside fixtures") do
+  %i[skip pending].each do |method_name|
+    fixture_class = Class.new(Smartest::Fixture) do
+      fixture :value do
+        __send__(method_name, "reason")
+      end
+    end
+
+    suite = Smartest::Suite.new
+    suite.fixture_classes.add(fixture_class)
+    suite.tests.add(SmartestSelfTest.test_case("#{method_name} fixture", proc { |value:| expect(value).to eq(:value) }))
+
+    status, output = SmartestSelfTest.run_suite(suite)
+
+    expect(status).to eq(1)
+    expect(output).to include("NoMethodError")
+    expect(output).to include(method_name.to_s)
+  end
+end
+
 test("supports basic matchers") do
   suite = Smartest::Suite.new
   suite.tests.add(
@@ -86,6 +172,15 @@ test("supports basic matchers") do
       "matchers",
       proc do
         expect([1, 2, 3]).to include(2)
+        expect("about:blank").to start_with("about:")
+        expect("https://cdn-b.test/assets/app.js").to start_with(
+          "https://cdn-a.test",
+          "https://cdn-b.test"
+        )
+        expect("screenshot.png").to end_with(".jpg", ".png")
+        expect("https://example.test").not_to start_with("about:")
+        expect("report.txt").not_to end_with(".png")
+        expect(Object.new).not_to start_with("prefix")
         expect(nil).to be_nil
         expect("value").not_to be_nil
         expect { raise ArgumentError, "bad" }.to raise_error(ArgumentError)
@@ -98,6 +193,93 @@ test("supports basic matchers") do
   expect(status).to eq(0)
 end
 
+test("reports start_with and end_with matcher failures") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad prefix",
+      proc { expect("https://example.test/path").to start_with("about:") }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad suffix",
+      proc { expect("asset.gif").to end_with(".jpg", ".png") }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad negated suffix",
+      proc { expect("screenshot.png").not_to end_with(".png") }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include('expected "https://example.test/path" to start with "about:"')
+  expect(output).to include('expected "asset.gif" to end with ".jpg" or ".png"')
+  expect(output).to include('expected "screenshot.png" not to end with ".png"')
+end
+
+test("supports change matcher for block expectations") do
+  value = 0
+  action_calls = 0
+
+  expect {
+    action_calls += 1
+    value += 2
+  }.to change { value }.from(0).to(2).by(2)
+
+  expect(action_calls).to eq(1)
+  expect { value }.not_to change { value }
+end
+
+test("reports change matcher failures with before and after values") do
+  value = 0
+
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect { value += 1 }.to change { value }.from(0).to(2).by(2)
+  end
+
+  expect(error.message).to include("0 before")
+  expect(error.message).to include("1 after")
+  expect(error.message).to include("to(2)")
+  expect(error.message).to include("by(2)")
+end
+
+test("fails negated change matcher when the value changes") do
+  value = 0
+
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect { value += 1 }.not_to change { value }
+  end
+
+  expect(error.message).to include("expected value not to change")
+  expect(error.message).to include("0 before")
+  expect(error.message).to include("1 after")
+end
+
+test("requires change matcher value and action blocks") do
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    change
+  end
+
+  expect(error.message).to eq("change requires a block")
+
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    change(:value) { :other }
+  end
+
+  expect(error.message).to include("change does not support arguments")
+
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect(:value).to change { :other }
+  end
+
+  expect(error.message).to include("expected a block to change value")
+end
+
 test("registers matcher modules for suite execution contexts") do
   status_matcher = Class.new do
     def initialize(expected)
@@ -563,6 +745,81 @@ test("around_test must call test.run") do
   expect(output).to include("Smartest::AroundTestRunError: around_test hook did not call test.run")
 end
 
+test("around_test can skip before test.run") do
+  events = []
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    Smartest::TestCase.new(
+      name: "skipped by hook",
+      metadata: {},
+      location: caller_locations(1, 1).first,
+      around_test_hooks: [
+        proc do |test_run|
+          events << :around_before
+          skip "browser is not supported"
+          test_run.run
+          events << :around_after
+        end
+      ],
+      block: proc { events << :test_body }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(events).to eq([:around_before])
+  expect(output).to include("- skipped by hook (skipped: browser is not supported)")
+  expect(output).to include("1 test, 0 passed, 0 failed, 1 skipped")
+end
+
+test("around_test can mark a failing test as pending") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    Smartest::TestCase.new(
+      name: "pending by hook",
+      metadata: {},
+      location: caller_locations(1, 1).first,
+      around_test_hooks: [
+        proc do |test_run|
+          pending "driver bug"
+          test_run.run
+        end
+      ],
+      block: proc { expect("actual").to eq("expected") }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(output).to include("* pending by hook (pending: driver bug)")
+  expect(output).to include("1 test, 0 passed, 0 failed, 1 pending")
+end
+
+test("pending around_test hooks must still call test.run") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    Smartest::TestCase.new(
+      name: "pending hook missing run",
+      metadata: {},
+      location: caller_locations(1, 1).first,
+      around_test_hooks: [
+        proc do |_test_run|
+          pending "driver bug"
+        end
+      ],
+      block: proc { expect(true).to eq(false) }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("Smartest::AroundTestRunError: around_test hook did not call test.run")
+  expect(output).to include("1 test, 0 passed, 1 failed")
+end
+
 test("use_fixture and use_matcher are only available inside hooks") do
   {
     "use_fixture Object" => "use_fixture",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.2.0.alpha1
+  version: 0.2.0.alpha3
 platform: ruby
 authors:
 - Yusuke Iwaki
@@ -65,6 +65,7 @@ files:
 - lib/smartest/test_registry.rb
 - lib/smartest/test_result.rb
 - lib/smartest/test_run.rb
+- lib/smartest/test_run_state.rb
 - lib/smartest/version.rb
 - smartest.gemspec
 - smartest/smartest_test.rb