smartest 0.1.0 → 0.2.0.alpha1

data/lib/smartest/runner.rb

@@ -11,10 +11,33 @@ module Smartest
     def run
       results = []
       suite_cleanup_errors = []
+      suite_errors = []
       @suite_fixture_set = nil
 
       @reporter.start(@tests.count)
 
+      begin
+        run_around_suite_hooks(@suite.around_suite_hooks.dup) do
+          run_tests(results, suite_cleanup_errors)
+        end
+      rescue Exception => error
+        raise if Smartest.fatal_exception?(error)
+
+        suite_errors << error
+      end
+
+      @reporter.finish(
+        results,
+        suite_cleanup_errors: suite_cleanup_errors,
+        suite_errors: suite_errors
+      )
+
+      results.any?(&:failed?) || suite_cleanup_errors.any? || suite_errors.any? ? 1 : 0
+    end
+
+    private
+
+    def run_tests(results, suite_cleanup_errors)
       begin
         @tests.each do |test_case|
           result = run_one(test_case)
@@ -22,34 +45,42 @@ module Smartest
           @reporter.record(result)
         end
       ensure
-        suite_cleanup_errors = @suite_fixture_set.run_cleanups if @suite_fixture_set
+        suite_cleanup_errors.concat(@suite_fixture_set.run_cleanups) if @suite_fixture_set
         @suite_fixture_set = nil
       end
+    end
 
-      @reporter.finish(results, suite_cleanup_errors: suite_cleanup_errors)
+    def run_around_suite_hooks(hooks, index = 0, &block)
+      return yield if index >= hooks.length
 
-      results.any?(&:failed?) || suite_cleanup_errors.any? ? 1 : 0
-    end
+      hook = hooks[index]
+      suite_run = SuiteRun.new do
+        run_around_suite_hooks(hooks, index + 1, &block)
+      end
 
-    private
+      AroundSuiteContext.new(@suite).call(hook, suite_run)
+      raise AroundSuiteRunError, "around_suite hook did not call suite.run" unless suite_run.ran?
+
+      suite_run.result
+    end
 
     def run_one(test_case)
       started_at = now
-      context = build_context
-      fixture_set = nil
       error = nil
       cleanup_errors = []
+      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)
+      end
 
       begin
-        fixture_set = FixtureSet.new(@suite.fixture_classes, context: context, parent: suite_fixture_set)
-        fixtures = fixture_set.resolve_keywords(test_case.fixture_names)
-        context.instance_exec(**fixtures, &test_case.block)
+        run_around_test_hooks(@suite.around_test_hooks + test_case.around_test_hooks, test_run)
       rescue Exception => rescued_error
         raise if Smartest.fatal_exception?(rescued_error)
 
         error = rescued_error
-      ensure
-        cleanup_errors = fixture_set.run_cleanups if fixture_set
       end
 
       duration = now - started_at
@@ -66,6 +97,39 @@ module Smartest
       end
     end
 
+    def run_test_body(test_case, fixture_classes, matcher_modules)
+      context = build_context(matcher_modules)
+      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
+      end
+
+      cleanup_errors
+    end
+
+    def run_around_test_hooks(hooks, test_run, index = 0)
+      return test_run.run if index >= hooks.length
+
+      hook = hooks[index]
+      next_run = TestRun.new(
+        fixture_classes: [],
+        matcher_modules: []
+      ) do |**_keywords|
+        run_around_test_hooks(hooks, test_run, index + 1)
+      end
+
+      AroundTestContext.new(test_run).call(hook, next_run)
+      raise AroundTestRunError, "around_test hook did not call test.run" unless next_run.ran?
+
+      next_run.result
+    end
+
     def suite_fixture_set
       @suite_fixture_set ||= FixtureSet.new(
         @suite.fixture_classes,
@@ -74,9 +138,9 @@ module Smartest
       )
     end
 
-    def build_context
+    def build_context(matcher_modules = @suite.matcher_modules)
       ExecutionContext.new.tap do |context|
-        @suite.matcher_modules.each { |matcher_module| context.extend(matcher_module) }
+        matcher_modules.each { |matcher_module| context.extend(matcher_module) }
       end
     end
 

data/lib/smartest/suite.rb

@@ -2,12 +2,45 @@
 
 module Smartest
   class Suite
-    attr_reader :tests, :fixture_classes, :matcher_modules
+    attr_reader :tests, :fixture_classes, :matcher_modules, :around_suite_hooks, :around_test_hooks
 
     def initialize
       @tests = TestRegistry.new
       @fixture_classes = FixtureClassRegistry.new
       @matcher_modules = MatcherRegistry.new
+      @around_suite_hooks = []
+      @around_test_hooks = []
+      @around_test_hooks_by_file = Hash.new { |hash, path| hash[path] = [] }
+      @around_suite_hook_depth = 0
+    end
+
+    def add_around_test_hook(location, hook)
+      if running_around_suite_hook?
+        @around_test_hooks << hook
+      else
+        @around_test_hooks_by_file[path_for(location)] << hook
+      end
+    end
+
+    def around_test_hooks_for(location)
+      @around_test_hooks_by_file[path_for(location)].dup
+    end
+
+    def around_suite_hook
+      @around_suite_hook_depth += 1
+      yield
+    ensure
+      @around_suite_hook_depth -= 1
+    end
+
+    private
+
+    def running_around_suite_hook?
+      @around_suite_hook_depth.positive?
+    end
+
+    def path_for(location)
+      File.expand_path(location.absolute_path || location.path)
     end
   end
 end

data/lib/smartest/suite_run.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Smartest
+  class SuiteRun
+    attr_reader :result
+
+    def initialize(&block)
+      @block = block
+      @ran = false
+      @result = nil
+    end
+
+    def run
+      raise AroundSuiteRunError, "around_suite hook called suite.run more than once" if ran?
+
+      @ran = true
+      @result = @block.call
+    end
+
+    def ran?
+      @ran
+    end
+  end
+end

data/lib/smartest/test_case.rb

@@ -2,9 +2,9 @@
 
 module Smartest
   class TestCase
-    attr_reader :name, :metadata, :block, :location, :fixture_names
+    attr_reader :name, :metadata, :block, :location, :fixture_names, :around_test_hooks
 
-    def initialize(name:, metadata:, block:, location:)
+    def initialize(name:, metadata:, block:, location:, around_test_hooks: [])
       raise ArgumentError, "test name is required" if name.nil? || name.to_s.empty?
       raise ArgumentError, "test block is required" unless block
 
@@ -12,6 +12,7 @@ module Smartest
       @metadata = metadata
       @block = block
       @location = location
+      @around_test_hooks = around_test_hooks.dup.freeze
       @fixture_names = ParameterExtractor.required_keyword_names(block, usage: :test)
     end
 

data/lib/smartest/test_run.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Smartest
+  class TestRun
+    attr_reader :result
+
+    def initialize(fixture_classes:, matcher_modules:, &block)
+      @fixture_classes = FixtureClassRegistry.new
+      fixture_classes.each { |fixture_class| @fixture_classes.add(fixture_class) }
+
+      @matcher_modules = MatcherRegistry.new
+      matcher_modules.each { |matcher_module| @matcher_modules.add(matcher_module) }
+
+      @block = block
+      @ran = false
+      @result = nil
+    end
+
+    def run
+      raise AroundTestRunError, "around_test hook called test.run more than once" if ran?
+
+      @ran = true
+      @result = @block.call(
+        fixture_classes: @fixture_classes,
+        matcher_modules: @matcher_modules
+      )
+    end
+
+    def ran?
+      @ran
+    end
+
+    def add_fixture_class(klass)
+      raise AroundTestRunError, "use_fixture must be called before test.run" if ran?
+
+      reject_suite_fixture_class!(klass)
+      @fixture_classes.add(klass)
+    end
+
+    def add_matcher_module(matcher_module)
+      raise AroundTestRunError, "use_matcher must be called before test.run" if ran?
+
+      @matcher_modules.add(matcher_module)
+    end
+
+    private
+
+    def reject_suite_fixture_class!(klass)
+      return unless klass.is_a?(Class) && klass <= Fixture
+
+      suite_fixture_names = klass.fixture_definitions.each_value.filter_map do |definition|
+        definition.name if definition.scope == :suite
+      end
+
+      raise AroundTestFixtureScopeError.new(klass, suite_fixture_names) if suite_fixture_names.any?
+    end
+  end
+end

data/lib/smartest/version.rb

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

data/lib/smartest.rb

@@ -11,6 +11,9 @@ require_relative "smartest/fixture_class_registry"
 require_relative "smartest/matcher_registry"
 require_relative "smartest/fixture_set"
 require_relative "smartest/suite"
+require_relative "smartest/suite_run"
+require_relative "smartest/test_run"
+require_relative "smartest/hook_contexts"
 require_relative "smartest/expectations"
 require_relative "smartest/expectation_target"
 require_relative "smartest/matchers"

data/smartest/smartest_test.rb

@@ -48,7 +48,10 @@ class SelfTestRegisteredFixture < Smartest::Fixture
   end
 end
 
-use_fixture SelfTestRegisteredFixture
+around_suite do |suite|
+  use_fixture SelfTestRegisteredFixture
+  suite.run
+end
 
 test("registers fixture classes with use_fixture") do |registered_user_name:|
   expect(registered_user_name).to eq("Alice")
@@ -326,6 +329,298 @@ test("suite fixture setup failures are cached and cleaned up once") do
   expect(output.scan("RuntimeError: server setup failed").length).to eq(2)
 end
 
+test("around_suite wraps tests and suite fixture cleanup") do
+  events = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    suite_fixture :server do
+      events << :server_setup
+      cleanup { events << :server_cleanup }
+      :server
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.around_suite_hooks << proc do |suite_run|
+    events << :around_before
+    suite_run.run
+    events << :around_after
+  end
+  suite.tests.add(SmartestSelfTest.test_case("uses server", proc { |server:| events << :test; expect(server).to eq(:server) }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(events).to eq(%i[around_before server_setup test server_cleanup around_after])
+end
+
+test("around_suite hooks run in registration order") do
+  events = []
+  suite = Smartest::Suite.new
+
+  suite.around_suite_hooks << proc do |suite_run|
+    events << :outer_before
+    suite_run.run
+    events << :outer_after
+  end
+  suite.around_suite_hooks << proc do |suite_run|
+    events << :inner_before
+    suite_run.run
+    events << :inner_after
+  end
+  suite.tests.add(SmartestSelfTest.test_case("passes", proc { events << :test }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(events).to eq(%i[outer_before inner_before test inner_after outer_after])
+end
+
+test("around_suite can register fixtures before running tests") do
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :user_name do
+      "Alice"
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.around_suite_hooks << proc do |suite_run|
+    use_fixture fixture_class
+    suite_run.run
+  end
+  suite.tests.add(SmartestSelfTest.test_case("uses runtime fixture", proc { |user_name:| expect(user_name).to eq("Alice") }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+end
+
+test("around_suite can register suite-wide around_test hooks") do
+  events = []
+  suite = Smartest::Suite.new
+
+  suite.around_suite_hooks << proc do |suite_run|
+    around_test do |test_run|
+      events << :around_test_before
+      test_run.run
+      events << :around_test_after
+    end
+
+    suite_run.run
+  end
+  suite.tests.add(SmartestSelfTest.test_case("passes", proc { events << :test }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(events).to eq(%i[around_test_before test around_test_after])
+end
+
+test("around_test wraps fixture setup, test body, and cleanup") do
+  events = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :resource do
+      events << :fixture_setup
+      cleanup { events << :fixture_cleanup }
+      :resource
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(
+    Smartest::TestCase.new(
+      name: "uses resource",
+      metadata: {},
+      location: caller_locations(1, 1).first,
+      around_test_hooks: [
+        proc do |test_run|
+          events << :around_test_before
+          test_run.run
+          events << :around_test_after
+        end
+      ],
+      block: proc { |resource:| events << :test; expect(resource).to eq(:resource) }
+    )
+  )
+
+  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])
+end
+
+test("around_test can register fixtures for one test run") do
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :local_value do
+      "local"
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    Smartest::TestCase.new(
+      name: "uses local fixture",
+      metadata: {},
+      location: caller_locations(1, 1).first,
+      around_test_hooks: [
+        proc do |test_run|
+          use_fixture fixture_class
+          test_run.run
+        end
+      ],
+      block: proc { |local_value:| expect(local_value).to eq("local") }
+    )
+  )
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+end
+
+test("around_test rejects fixture classes with suite fixtures") do
+  fixture_class = Class.new(Smartest::Fixture) do
+    suite_fixture :server do
+      :server
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    Smartest::TestCase.new(
+      name: "rejects local suite fixture",
+      metadata: {},
+      location: caller_locations(1, 1).first,
+      around_test_hooks: [
+        proc do |test_run|
+          use_fixture fixture_class
+          test_run.run
+        end
+      ],
+      block: proc { |server:| expect(server).to eq(:server) }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("Smartest::AroundTestFixtureScopeError")
+  expect(output).to include("cannot be registered from around_test")
+  expect(output).to include("suite-scoped fixtures: :server")
+  expect(output).to include("Register fixture classes with suite_fixture from around_suite instead.")
+end
+
+test("around_test can register matchers for one test run") do
+  matcher_module = Module.new do
+    define_method(:equal_local) do |expected|
+      Class.new do
+        define_method(:initialize) { |value| @expected = value }
+        define_method(:matches?) { |actual| actual == @expected }
+        define_method(:failure_message) { "expected value to match" }
+        define_method(:negated_failure_message) { "expected value not to match" }
+      end.new(expected)
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    Smartest::TestCase.new(
+      name: "uses local matcher",
+      metadata: {},
+      location: caller_locations(1, 1).first,
+      around_test_hooks: [
+        proc do |test_run|
+          use_matcher matcher_module
+          test_run.run
+        end
+      ],
+      block: proc { expect("local").to equal_local("local") }
+    )
+  )
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+end
+
+test("around_test must call test.run") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    Smartest::TestCase.new(
+      name: "not reached",
+      metadata: {},
+      location: caller_locations(1, 1).first,
+      around_test_hooks: [proc { |_test_run| nil }],
+      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")
+end
+
+test("use_fixture and use_matcher are only available inside hooks") do
+  {
+    "use_fixture Object" => "use_fixture",
+    "use_matcher Module.new" => "use_matcher"
+  }.each do |registration, method_name|
+    Dir.mktmpdir do |dir|
+      smartest_dir = File.join(dir, "smartest")
+      FileUtils.mkdir_p(smartest_dir)
+      File.write(File.join(smartest_dir, "sample_test.rb"), <<~RUBY)
+        require "smartest/autorun"
+
+        #{registration}
+
+        test("not reached") do
+          expect(true).to eq(true)
+        end
+      RUBY
+
+      _stdout, stderr, status = Open3.capture3(
+        { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+        "ruby",
+        File.expand_path("../exe/smartest", __dir__),
+        "smartest/sample_test.rb",
+        chdir: dir
+      )
+
+      expect(status.success?).to eq(false)
+      expect(stderr).to include("Error loading tests:")
+      expect(stderr).to include("NoMethodError")
+      expect(stderr).to include(method_name)
+    end
+  end
+end
+
+test("around_suite failures fail the run") do
+  suite = Smartest::Suite.new
+  suite.around_suite_hooks << proc { |_suite_run| raise "suite wrapper failed" }
+  suite.tests.add(SmartestSelfTest.test_case("not reached", proc { expect(true).to eq(false) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("Suite failures:")
+  expect(output).to include("RuntimeError: suite wrapper failed")
+  expect(output).to include("0 tests, 0 passed, 0 failed, 1 suite failure")
+end
+
+test("around_suite must call suite.run") do
+  suite = Smartest::Suite.new
+  suite.around_suite_hooks << proc { |_suite_run| nil }
+  suite.tests.add(SmartestSelfTest.test_case("not reached", proc { expect(true).to eq(false) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("Smartest::AroundSuiteRunError: around_suite hook did not call suite.run")
+end
+
 test("suite cleanup failures fail the run") do
   fixture_class = Class.new(Smartest::Fixture) do
     suite_fixture :browser do
@@ -541,7 +836,10 @@ test("cli loads matcher files registered in test helper") do
         require matcher_file
       end
 
-      use_matcher HaveStatusMatcher
+      around_suite do |suite|
+        use_matcher HaveStatusMatcher
+        suite.run
+      end
     RUBY
     File.write(File.join(matchers_dir, "have_status_matcher.rb"), <<~RUBY)
       module HaveStatusMatcher
@@ -771,6 +1069,7 @@ test("cli initializes a runnable test scaffold") do
     expect(helper_contents).to include('require "smartest/autorun"')
     expect(helper_contents).to include('Dir[File.join(__dir__, "fixtures", "**", "*.rb")].sort.each')
     expect(helper_contents).to include('Dir[File.join(__dir__, "matchers", "**", "*.rb")].sort.each')
+    expect(helper_contents).to include("around_suite do |suite|")
     expect(helper_contents).to include("use_matcher PredicateMatcher")
     predicate_matcher_contents = File.read(File.join(dir, "smartest/matchers/predicate_matcher.rb"))
     expect(predicate_matcher_contents).to include("module PredicateMatcher")
@@ -789,7 +1088,10 @@ test("cli initializes a runnable test scaffold") do
     File.write(File.join(dir, "smartest/auto_loaded_fixture_test.rb"), <<~RUBY)
       require "test_helper"
 
-      use_fixture AutoLoadedFixture
+      around_test do |test|
+        use_fixture AutoLoadedFixture
+        test.run
+      end
 
       test("auto-loaded fixture") do |auto_loaded_message:|
         expect(auto_loaded_message).to eq("loaded from smartest/fixtures")
@@ -828,7 +1130,10 @@ test("cli initializes a runnable test scaffold") do
     File.write(File.join(dir, "smartest/auto_loaded_matcher_test.rb"), <<~RUBY)
       require "test_helper"
 
-      use_matcher AutoLoadedMatcher
+      around_test do |test|
+        use_matcher AutoLoadedMatcher
+        test.run
+      end
 
       test("auto-loaded matcher") do
         expect("loaded from smartest/matchers").to auto_eq("loaded from smartest/matchers")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0.alpha1
 platform: ruby
 authors:
 - Yusuke Iwaki
@@ -52,6 +52,7 @@ files:
 - lib/smartest/fixture_class_registry.rb
 - lib/smartest/fixture_definition.rb
 - lib/smartest/fixture_set.rb
+- lib/smartest/hook_contexts.rb
 - lib/smartest/init_generator.rb
 - lib/smartest/matcher_registry.rb
 - lib/smartest/matchers.rb
@@ -59,9 +60,11 @@ files:
 - lib/smartest/reporter.rb
 - lib/smartest/runner.rb
 - lib/smartest/suite.rb
+- lib/smartest/suite_run.rb
 - lib/smartest/test_case.rb
 - lib/smartest/test_registry.rb
 - lib/smartest/test_result.rb
+- lib/smartest/test_run.rb
 - lib/smartest/version.rb
 - smartest.gemspec
 - smartest/smartest_test.rb
@@ -86,9 +89,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.19
 signing_key: