smartest 0.3.3.alpha3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46365bf842594d74023e6c47da5b98f28e2f8ad765a035de09a54f5d127db2ee
-  data.tar.gz: 53134bcd0052d5cd8b495b36a9ba8bb1344c6dcb0626d0547dfa49bf6eff005e
+  metadata.gz: 3d2b5aeaf51e6e6878eac74601d634daab2e423cede641216856a79188c28554
+  data.tar.gz: 4f90e558f84062585a0a8b3596c91f9507f9fec09430a86c6782ae7a3ba92bb7
 SHA512:
-  metadata.gz: a5ffe755697e79babe4e54e52d9a2e2a13aee1ade7306dfa7adffd7d9ea6ca75b7b96825b05c713261f420f35b28e980a85b068a94823109bffc0a54774d864a
-  data.tar.gz: c030cd6bfcfb44f8273348f99a36a6213c237c9bd580cd49287351b4bf9b70a04af3b6b7889287f12ffbda747dfd7d6a450b9954bf51f8c2bdf5fb71768027ba
+  metadata.gz: 687150dcb8a16d475d76b9840fecf63b7705fc0b5e123380d6ffe3fe415a77ed89228bdbc098e66db22d67164f4b43412229e47311be15b6ab09643bf00aa43f
+  data.tar.gz: 037f50862bd76bcb86e4511227a8a5f2ce943e37fdce3d823124ff90872efa1a808bb7eee4a2ab9c0985c685baf2db451c304074e6797f88d1c2f370390adea6

data/DEVELOPMENT.md

@@ -46,6 +46,7 @@ smartest/
       expectation_target.rb
       matchers.rb
       simple_stub.rb
+      constant_stub_helpers.rb
 
       runner.rb
       test_result.rb
@@ -647,6 +648,10 @@ A practical approach:
 - `exe/smartest`
 - load files from ARGV
 - default glob `smartest/**/*_test.rb`
+- print scaffold guidance and exit 1 when the default run is requested before
+  `smartest/` exists
+- expand directory path arguments such as `smartest/` to `**/*_test.rb` files
+  under that directory
 - support `path:line` and `path:start-end` filters that run tests whose `test`
   blocks contain or intersect the lines
 - add `smartest/` to the load path before loading tests

data/README.md

@@ -123,12 +123,34 @@ bundle exec smartest
 By default, Smartest loads `smartest/**/*_test.rb`, so a separate `test/`
 directory can remain available for Minitest.
 
+If `smartest/` does not exist yet and no explicit paths are passed, Smartest
+prints scaffold commands instead of attempting a default test run:
+
+```text
+No smartest/ directory found.
+
+To create a Smartest test scaffold:
+  bundle exec smartest --init
+
+For browser tests:
+  bundle exec smartest --init-browser
+
+See all commands:
+  bundle exec smartest --help
+```
+
 You can also pass explicit paths:
 
 ```bash
+bundle exec smartest smartest/suite1/
 bundle exec smartest smartest/**/*_test.rb
+bundle exec smartest smartest/user_test.rb
 ```
 
+A directory path is expanded to `**/*_test.rb` under that directory, so
+`bundle exec smartest smartest/suite1/` is equivalent to
+`bundle exec smartest smartest/suite1/**/*_test.rb`.
+
 To run tests by line number, append `:line` or `:start-end` to the file path.
 Smartest runs tests whose `test` blocks contain or intersect the selected lines:
 
@@ -152,6 +174,18 @@ bundle exec smartest --help
 bundle exec smartest --version
 ```
 
+The help output lists common commands, including default runs, directory runs,
+single-file runs, line-filtered runs, and scaffold generation:
+
+```bash
+bundle exec smartest
+bundle exec smartest smartest/suite1/
+bundle exec smartest smartest/user_test.rb
+bundle exec smartest smartest/user_test.rb:12
+bundle exec smartest --init
+bundle exec smartest --init-browser
+```
+
 Output resembles:
 
 ```text
@@ -637,16 +671,16 @@ end
 ```
 
 Use `simple_stub(Time, :now) { fixed_time }` for singleton methods such as class
-methods. Use `simple_stub_const("AppConfig::PAYMENT_PROVIDER", "fake")` for
-constants. Constant stubs are process-global; avoid concurrent tests that stub
-the same constant.
+methods.
+
+Use `with_stub_const("AppConfig::PAYMENT_PROVIDER", "fake") { ... }` for
+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.
-`simple_stub_const` records the previous constant value, replaces it, and
-restores or removes it during cleanup. These helpers are available inside
-`Smartest::Fixture` fixture blocks because they need cleanup to tie the stub
-lifetime to the fixture scope.
+`with_stub_const` records the previous constant value, replaces it, yields to
+the block, and restores or removes the constant with `ensure`.
 
 `Smartest::SimpleStub#apply` and `#reset` are idempotent in the current Fiber.
 `apply!` raises
@@ -880,7 +914,7 @@ Smartest currently focuses on a small runner API:
 - fixture dependencies through keyword arguments
 - fixture cleanup
 - suite-scoped fixtures through `suite_fixture`
-- fixture-scoped method and constant stubs
+- fixture-scoped method stubs and block-scoped constant stubs
 - suite hooks with `around_suite`
 - test hooks with `around_test`
 - skipped and pending tests through `skip` and `pending`

data/SMARTEST_DESIGN.md

@@ -856,7 +856,24 @@ If no paths are given:
 bundle exec smartest
 ```
 
-should default to:
+should default to `smartest/**/*_test.rb` when `smartest/` exists. If the
+directory does not exist, the CLI should print scaffold guidance and exit with
+status `1`:
+
+```text
+No smartest/ directory found.
+
+To create a Smartest test scaffold:
+  bundle exec smartest --init
+
+For browser tests:
+  bundle exec smartest --init-browser
+
+See all commands:
+  bundle exec smartest --help
+```
+
+Default paths:
 
 ```text
 smartest/**/*_test.rb
@@ -877,8 +894,8 @@ arguments.files.each { |file| load File.expand_path(file) }
 exit Smartest::Runner.new(tests: arguments.select_tests(Smartest.suite.tests)).run
 ```
 
-`Smartest::CLIArguments` should support file paths, shell globs, `path:line`,
-and `path:start-end` filters.
+`Smartest::CLIArguments` should support file paths, directory paths, shell
+globs, `path:line`, and `path:start-end` filters.
 
 `smartest/autorun` should use `at_exit`.
 

data/exe/smartest

@@ -7,18 +7,51 @@ require "smartest"
 
 usage = <<~USAGE
   Usage:
-    smartest [--profile N] [paths...]
-    smartest [--profile N] path/to/test_file.rb:line[-line]
-    smartest --init
-    smartest --init-browser
-    smartest --version
-    smartest --help
-
-  When no paths are given, Smartest loads smartest/**/*_test.rb.
-  Smartest prints the 5 slowest tests after the run by default.
-  Use --profile N to choose how many slowest tests are printed.
+    bundle exec smartest [options] [paths...]
+
+  Common commands:
+    bundle exec smartest
+        Run tests under smartest/**/*_test.rb
+
+    bundle exec smartest smartest/suite1/
+        Run test files matching smartest/suite1/**/*_test.rb
+
+    bundle exec smartest smartest/user_test.rb
+        Run one test file
+
+    bundle exec smartest smartest/user_test.rb:12
+        Run tests around line 12
+
+    bundle exec smartest --init
+        Generate a basic Smartest scaffold
+
+    bundle exec smartest --init-browser
+        Generate a Playwright browser-test scaffold
+
+  Options:
+    --profile N
+        Print the N slowest tests. Defaults to 5.
+
+    --version, -v
+        Print the installed Smartest version.
+
+    --help, -h
+        Print this help.
 USAGE
 
+missing_smartest_directory_message = <<~MESSAGE
+  No smartest/ directory found.
+
+  To create a Smartest test scaffold:
+    bundle exec smartest --init
+
+  For browser tests:
+    bundle exec smartest --init-browser
+
+  See all commands:
+    bundle exec smartest --help
+MESSAGE
+
 command = :run
 
 begin
@@ -45,10 +78,16 @@ begin
   Smartest.disable_autorun!
   Smartest.install_dsl!
   test_load_path = File.expand_path("smartest", Dir.pwd)
-  $LOAD_PATH.unshift(test_load_path) if Dir.exist?(test_load_path) && !$LOAD_PATH.include?(test_load_path)
 
   arguments = Smartest::CLIArguments.new(ARGV)
 
+  if arguments.default_paths? && !Dir.exist?(test_load_path)
+    puts missing_smartest_directory_message
+    exit 1
+  end
+
+  $LOAD_PATH.unshift(test_load_path) if Dir.exist?(test_load_path) && !$LOAD_PATH.include?(test_load_path)
+
   arguments.files.each do |file|
     load File.expand_path(file)
   end

data/lib/smartest/cli_arguments.rb

@@ -5,6 +5,7 @@ require "set"
 module Smartest
   class CLIArguments
     DEFAULT_PROFILE_COUNT = 5
+    DEFAULT_PATHS = ["smartest/**/*_test.rb"].freeze
 
     attr_reader :files, :line_filters, :profile_count
 
@@ -13,15 +14,25 @@ module Smartest
       @whole_files = Set.new
       @line_filters = Hash.new { |hash, key| hash[key] = Set.new }
       @profile_count = DEFAULT_PROFILE_COUNT
+      @default_paths = false
 
       paths = extract_options(argv)
-      parse_paths(paths.empty? ? ["smartest/**/*_test.rb"] : paths)
+      if paths.empty?
+        @default_paths = true
+        paths = DEFAULT_PATHS
+      end
+
+      parse_paths(paths)
     end
 
     def filter_tests?
       @line_filters.any?
     end
 
+    def default_paths?
+      @default_paths
+    end
+
     def select_tests(tests)
       return tests unless filter_tests?
 
@@ -64,8 +75,7 @@ module Smartest
     def parse_paths(paths)
       paths.each do |argument|
         pattern, line_filter = split_line_filter(argument)
-        matches = Dir[pattern]
-        files = matches.empty? ? [pattern] : matches
+        files = expand_path_pattern(pattern)
 
         files.each do |file|
           @files << file
@@ -82,6 +92,19 @@ module Smartest
       @files.uniq!
     end
 
+    def expand_path_pattern(pattern)
+      matches = Dir[pattern]
+      return [pattern] if matches.empty?
+
+      matches.flat_map do |match|
+        if File.directory?(match)
+          Dir[File.join(match, "**", "*_test.rb")]
+        else
+          match
+        end
+      end
+    end
+
     def split_line_filter(argument)
       match = argument.match(/\A(.+):(\d+)(?:-(\d+))?\z/)
       return [argument, nil] unless match

data/lib/smartest/constant_stub_helpers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Smartest
+  module ConstantStubHelpers
+    private
+
+    def with_stub_const(constant_path, value)
+      raise ArgumentError, "with_stub_const block is required" unless block_given?
+
+      owner, constant_name = resolve_with_stub_constant(constant_path)
+      original_defined = owner.const_defined?(constant_name, false)
+      original_value = owner.const_get(constant_name, false) if original_defined
+
+      owner.__send__(:remove_const, constant_name) if original_defined
+      owner.const_set(constant_name, value)
+
+      yield
+    ensure
+      if owner && constant_name
+        owner.__send__(:remove_const, constant_name) if owner.const_defined?(constant_name, false)
+        owner.const_set(constant_name, original_value) if original_defined
+      end
+    end
+
+    def resolve_with_stub_constant(constant_path)
+      unless constant_path.is_a?(String) || constant_path.is_a?(Symbol)
+        raise ArgumentError, "constant path must be a String or Symbol"
+      end
+
+      names = constant_path.to_s.split("::")
+      names.shift if names.first == ""
+      raise ArgumentError, "constant path must not be empty" if names.empty?
+
+      names.each do |name|
+        raise ArgumentError, "invalid constant path: #{constant_path}" unless name.match?(/\A[A-Z]\w*\z/)
+      end
+
+      constant_name = names.pop.to_sym
+      owner = names.reduce(Object) { |namespace, name| namespace.const_get(name, false) }
+      raise ArgumentError, "constant owner must be a Module or Class" unless owner.is_a?(Module)
+
+      [owner, constant_name]
+    end
+  end
+end

data/lib/smartest/execution_context.rb

@@ -4,6 +4,7 @@ module Smartest
   class ExecutionContext
     include Expectations
     include Matchers
+    include ConstantStubHelpers
 
     def initialize(run_state: TestRunState.new)
       @run_state = run_state

data/lib/smartest/fixture.rb

@@ -2,7 +2,7 @@
 
 module Smartest
   class Fixture
-    RESERVED_CONTEXT_METHODS = %i[skip pending].freeze
+    RESERVED_CONTEXT_METHODS = %i[skip pending with_stub_const].freeze
 
     class << self
       def fixture(name, scope: :test, &block)
@@ -73,48 +73,12 @@ module Smartest
       apply_simple_stub(SimpleStub.new(object.singleton_class, method_name, &block))
     end
 
-    def simple_stub_const(constant_path, value)
-      owner, constant_name = resolve_simple_stub_constant(constant_path)
-      original_defined = owner.const_defined?(constant_name, false)
-      original_value = owner.const_get(constant_name, false) if original_defined
-
-      owner.__send__(:remove_const, constant_name) if original_defined
-      owner.const_set(constant_name, value)
-
-      cleanup do
-        owner.__send__(:remove_const, constant_name) if owner.const_defined?(constant_name, false)
-        owner.const_set(constant_name, original_value) if original_defined
-      end
-
-      value
-    end
-
     def apply_simple_stub(stub)
       stub.apply!
       cleanup { stub.reset }
       stub
     end
 
-    def resolve_simple_stub_constant(constant_path)
-      unless constant_path.is_a?(String) || constant_path.is_a?(Symbol)
-        raise ArgumentError, "constant path must be a String or Symbol"
-      end
-
-      names = constant_path.to_s.split("::")
-      names.shift if names.first == ""
-      raise ArgumentError, "constant path must not be empty" if names.empty?
-
-      names.each do |name|
-        raise ArgumentError, "invalid constant path: #{constant_path}" unless name.match?(/\A[A-Z]\w*\z/)
-      end
-
-      constant_name = names.pop.to_sym
-      owner = names.reduce(Object) { |namespace, name| namespace.const_get(name, false) }
-      raise ArgumentError, "constant owner must be a Module or Class" unless owner.is_a?(Module)
-
-      [owner, constant_name]
-    end
-
     def method_missing(method_name, *args, &block)
       return super if RESERVED_CONTEXT_METHODS.include?(method_name)
 

data/lib/smartest/hook_contexts.rb

@@ -2,6 +2,8 @@
 
 module Smartest
   class AroundSuiteContext
+    include ConstantStubHelpers
+
     def initialize(suite)
       @suite = suite
     end
@@ -30,6 +32,8 @@ module Smartest
   end
 
   class AroundTestContext
+    include ConstantStubHelpers
+
     def initialize(test_run, run_state:)
       @test_run = test_run
       @run_state = run_state

data/lib/smartest/version.rb

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

data/lib/smartest.rb

@@ -3,6 +3,7 @@
 require_relative "smartest/version"
 require_relative "smartest/errors"
 require_relative "smartest/simple_stub"
+require_relative "smartest/constant_stub_helpers"
 require_relative "smartest/parameter_extractor"
 require_relative "smartest/test_case"
 require_relative "smartest/test_registry"

data/smartest/simple_stub_test.rb

@@ -158,64 +158,101 @@ test("simple_stub applies and resets singleton methods from fixture cleanup") do
   expect(status).to eq(0)
 end
 
-test("simple_stub_const applies and resets existing constants from fixture cleanup") do
-  fixture_class = Class.new(Smartest::Fixture) do
-    fixture :stubbed_provider do
-      simple_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider)
+test("with_stub_const applies and resets existing constants in test body blocks") do
+  result = with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider) do
+    expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:stubbed_provider)
+    :block_result
+  end
+
+  expect(result).to eq(:block_result)
+  expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
+end
+
+test("with_stub_const removes newly defined constants after test body blocks") do
+  with_stub_const("SimpleStubSelfTestConfig::MISSING_PROVIDER", :stubbed_missing_provider) do
+    expect(SimpleStubSelfTestConfig::MISSING_PROVIDER).to eq(:stubbed_missing_provider)
+  end
+
+  expect(SimpleStubSelfTestConfig.const_defined?(:MISSING_PROVIDER, false)).to eq(false)
+end
+
+test("with_stub_const restores constants when the block raises") do
+  error = SimpleStubSelfTest.capture_error(RuntimeError) do
+    with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider) do
+      expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:stubbed_provider)
+      raise "stubbed block failed"
     end
   end
 
+  expect(error.message).to eq("stubbed block failed")
+  expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
+end
+
+test("with_stub_const requires a block") do
+  error = SimpleStubSelfTest.capture_error(ArgumentError) do
+    with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :stubbed_provider)
+  end
+
+  expect(error.message).to eq("with_stub_const block is required")
+end
+
+test("with_stub_const wraps around_test hooks") do
   suite = Smartest::Suite.new
-  suite.fixture_classes.add(fixture_class)
+  suite.around_test_hooks << proc do |test_run|
+    with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :around_test_provider) do
+      test_run.run
+    end
+  end
   suite.tests.add(
     SimpleStubSelfTest.test_case(
-      "uses constant stub fixture",
-      proc do |stubbed_provider:|
-        expect(stubbed_provider).to eq(:stubbed_provider)
-        expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:stubbed_provider)
-      end
+      "uses around_test constant stub",
+      proc { expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:around_test_provider) }
     )
   )
+
+  status, = SimpleStubSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
+end
+
+test("with_stub_const wraps around_suite hooks") do
+  suite = Smartest::Suite.new
+  suite.around_suite_hooks << proc do |suite_run|
+    with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :around_suite_provider) do
+      suite_run.run
+    end
+  end
   suite.tests.add(
     SimpleStubSelfTest.test_case(
-      "sees restored constant",
-      proc { expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider) }
+      "uses around_suite constant stub",
+      proc { expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:around_suite_provider) }
     )
   )
 
   status, = SimpleStubSelfTest.run_suite(suite)
 
   expect(status).to eq(0)
+  expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
 end
 
-test("simple_stub_const removes newly defined constants from fixture cleanup") do
+test("with_stub_const is not available inside fixture blocks") do
   fixture_class = Class.new(Smartest::Fixture) do
-    fixture :stubbed_missing_provider do
-      simple_stub_const("SimpleStubSelfTestConfig::MISSING_PROVIDER", :stubbed_missing_provider)
+    fixture :bad_constant_stub do
+      with_stub_const("SimpleStubSelfTestConfig::PROVIDER", :fixture_provider) { :fixture_provider }
     end
   end
 
   suite = Smartest::Suite.new
   suite.fixture_classes.add(fixture_class)
-  suite.tests.add(
-    SimpleStubSelfTest.test_case(
-      "uses new constant stub fixture",
-      proc do |stubbed_missing_provider:|
-        expect(stubbed_missing_provider).to eq(:stubbed_missing_provider)
-        expect(SimpleStubSelfTestConfig::MISSING_PROVIDER).to eq(:stubbed_missing_provider)
-      end
-    )
-  )
-  suite.tests.add(
-    SimpleStubSelfTest.test_case(
-      "sees removed constant",
-      proc { expect(SimpleStubSelfTestConfig.const_defined?(:MISSING_PROVIDER, false)).to eq(false) }
-    )
-  )
+  suite.tests.add(SimpleStubSelfTest.test_case("uses bad fixture", proc { |bad_constant_stub:| bad_constant_stub }))
 
-  status, = SimpleStubSelfTest.run_suite(suite)
+  status, output = SimpleStubSelfTest.run_suite(suite)
 
-  expect(status).to eq(0)
+  expect(status).to eq(1)
+  expect(output).to include("NoMethodError")
+  expect(output).to include("with_stub_const")
+  expect(SimpleStubSelfTestConfig::PROVIDER).to eq(:original_provider)
 end
 
 test("simple stub preserves receiver self and method blocks") do

data/smartest/smartest_test.rb

@@ -1435,6 +1435,44 @@ test("cli loads files and returns failure status") do
   end
 end
 
+test("cli expands directory paths to tests under that directory") do
+  Dir.mktmpdir do |dir|
+    smartest_dir = File.join(dir, "smartest")
+    FileUtils.mkdir_p(File.join(smartest_dir, "nested"))
+    File.write(File.join(smartest_dir, "test_helper.rb"), <<~RUBY)
+      require "smartest/autorun"
+    RUBY
+    File.write(File.join(smartest_dir, "root_test.rb"), <<~RUBY)
+      require "test_helper"
+
+      test("root directory test") do
+        expect(1).to eq(1)
+      end
+    RUBY
+    File.write(File.join(smartest_dir, "nested", "nested_test.rb"), <<~RUBY)
+      require "test_helper"
+
+      test("nested directory test") do
+        expect(2).to eq(2)
+      end
+    RUBY
+
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      "smartest/",
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(true)
+    expect(stderr).to eq("")
+    expect(stdout).to include("root directory test")
+    expect(stdout).to include("nested directory test")
+    expect(stdout).to include("2 tests, 2 passed, 0 failed")
+  end
+end
+
 test("cli loads matcher files registered in test helper") do
   Dir.mktmpdir do |dir|
     smartest_dir = File.join(dir, "smartest")
@@ -1656,14 +1694,61 @@ test("cli prints help") do
   expect(status.success?).to eq(true)
   expect(stderr).to eq("")
   expect(stdout).to include("Usage:")
-  expect(stdout).to include("smartest [--profile N] [paths...]")
-  expect(stdout).to include("smartest [--profile N] path/to/test_file.rb:line[-line]")
-  expect(stdout).to include("smartest --init")
-  expect(stdout).to include("smartest --init-browser")
-  expect(stdout).to include("Use --profile N")
+  expect(stdout).to include("bundle exec smartest [options] [paths...]")
+  expect(stdout).to include("Common commands:")
+  expect(stdout).to include("bundle exec smartest smartest/suite1/")
+  expect(stdout).to include("Run test files matching smartest/suite1/**/*_test.rb")
+  expect(stdout).to include("bundle exec smartest smartest/user_test.rb")
+  expect(stdout).to include("bundle exec smartest smartest/user_test.rb:12")
+  expect(stdout).not_to include("bundle exec smartest smartest/example_browser_test.rb")
+  expect(stdout).not_to include("Run a browser test file")
+  expect(stdout).to include("bundle exec smartest --init")
+  expect(stdout).to include("bundle exec smartest --init-browser")
+  expect(stdout).to include("--profile N")
   expect(stdout).to include("smartest/**/*_test.rb")
 end
 
+test("cli explains how to initialize when default smartest directory is missing") do
+  Dir.mktmpdir do |dir|
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(false)
+    expect(stderr).to eq("")
+    expect(stdout).to include("No smartest/ directory found.")
+    expect(stdout).to include("bundle exec smartest --init")
+    expect(stdout).to include("bundle exec smartest --init-browser")
+    expect(stdout).to include("bundle exec smartest --help")
+  end
+end
+
+test("cli still runs explicit paths when default smartest directory is missing") do
+  Dir.mktmpdir do |dir|
+    File.write(File.join(dir, "sample_test.rb"), <<~RUBY)
+      test("explicit path") do
+        expect(1).to eq(1)
+      end
+    RUBY
+
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      "sample_test.rb",
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(true)
+    expect(stderr).to eq("")
+    expect(stdout).to include("explicit path")
+    expect(stdout).to include("1 test, 1 passed, 0 failed")
+  end
+end
+
 test("--profile prints the slowest tests with default count of 5") do
   output = StringIO.new
   reporter = Smartest::Reporter.new(output, profile_count: 5)
@@ -1760,7 +1845,9 @@ test("CLIArguments defaults profile count and parses --profile N") do
 
   expect(arguments.profile_count).to eq(5)
   expect(arguments.files).to eq(Dir["smartest/**/*_test.rb"])
+  expect(arguments.default_paths?).to eq(true)
   expect(Smartest::CLIArguments.new(["--profile", "3"]).profile_count).to eq(3)
+  expect(Smartest::CLIArguments.new(["smartest/foo_test.rb"]).default_paths?).to eq(false)
 end
 
 test("CLIArguments leaves unsupported profile forms as paths") do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.3.3.alpha3
+  version: 0.4.0
 platform: ruby
 authors:
 - Yusuke Iwaki
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-04 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -44,6 +44,7 @@ files:
 - lib/smartest.rb
 - lib/smartest/autorun.rb
 - lib/smartest/cli_arguments.rb
+- lib/smartest/constant_stub_helpers.rb
 - lib/smartest/dsl.rb
 - lib/smartest/errors.rb
 - lib/smartest/execution_context.rb
@@ -96,9 +97,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.19
 signing_key: