smartest 0.2.0.alpha1 → 0.2.0.alpha2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee5c1b7be401fa3dc4a8d88a25a241fc2b0bad486e8a3163a83c6c2340ae7c3c
-  data.tar.gz: f063204cd31bcd99b4654c26bb8591d566dcd424a2a312d9a7c9cbbea4292b01
+  metadata.gz: e0953c11bf61f80c4a310701920e5b6a22727149ed135d86678b3e49b25c8a92
+  data.tar.gz: d51839a9cb597da3d63a15aa803661946ceb3ae2a6982317ea108797f4203380
 SHA512:
-  metadata.gz: 18f117d867c86f47ff3d517729c0e7cbae4af5933b7432fa96ad30b1aea58a76b48e7ae4d3c129e72594598d19297751513d49501e5481c9ef07259a5350dafb
-  data.tar.gz: '085a5a10a7d5248d7888fd6267edae7c4dd88077f5b413d45385d4c05245b0eae771975ab67a50befc8ca14d8acb3d148d9718d94b431caf9800d2a2daa78627'
+  metadata.gz: 2e3be2ebdc5b116e6f16e396d4befda198c0063bb4da6e7f487266642d1edd8083bcc4dce9b37746969fdcbd9916424068f043344cc732edf4738f849fb87d9c
+  data.tar.gz: 0c299af8b8dd05fac80ec1eefaeade8f747f8d2776e87ba6cb684ff84c619be8a21dfd3e33c99fa43d05ee0d40aabc361f86ab1e33af696a5a9ef4c9ee78054d

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:
@@ -648,6 +676,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.
 
@@ -831,28 +834,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,11 +1211,25 @@ 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

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/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/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.alpha2"
 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(
@@ -563,6 +649,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.alpha2
 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