smartest 0.1.0.alpha1

data/smartest/smartest_test.rb

@@ -0,0 +1,634 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "smartest/autorun"
+require "fileutils"
+require "stringio"
+require "open3"
+require "tmpdir"
+
+module SmartestSelfTest
+  module_function
+
+  def test_case(name, block)
+    Smartest::TestCase.new(
+      name: name,
+      metadata: {},
+      block: block,
+      location: caller_locations(1, 1).first
+    )
+  end
+
+  def run_suite(suite)
+    output = StringIO.new
+    status = Smartest::Runner.new(suite: suite, reporter: Smartest::Reporter.new(output)).run
+
+    [status, output.string]
+  end
+
+  def capture_error(expected_error)
+    yield
+  rescue Exception => error
+    raise if Smartest.fatal_exception?(error)
+
+    unless error.is_a?(expected_error)
+      raise Smartest::AssertionFailed, "expected #{expected_error}, but raised #{error.class}: #{error.message}"
+    end
+
+    error
+  else
+    raise Smartest::AssertionFailed, "expected #{expected_error}, but nothing was raised"
+  end
+end
+
+class SelfTestRegisteredFixture < Smartest::Fixture
+  fixture :registered_user_name do
+    "Alice"
+  end
+end
+
+use_fixture SelfTestRegisteredFixture
+
+test("registers fixture classes with use_fixture") do |registered_user_name:|
+  expect(registered_user_name).to eq("Alice")
+end
+
+test("runs a registered test") do
+  suite = Smartest::Suite.new
+  suite.tests.add(SmartestSelfTest.test_case("factorial", proc { expect(1 * 2 * 3).to eq(6) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(output).to include("Running 1 test")
+  expect(output).to include("1 test, 1 passed, 0 failed")
+end
+
+test("reports expectation failures") do
+  suite = Smartest::Suite.new
+  suite.tests.add(SmartestSelfTest.test_case("bad math", proc { expect(1 + 1).to eq(3) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("expected 2 to eq 3")
+  expect(output).to include("1 test, 0 passed, 1 failed")
+end
+
+test("supports basic matchers") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "matchers",
+      proc do
+        expect([1, 2, 3]).to include(2)
+        expect(nil).to be_nil
+        expect("value").not_to be_nil
+        expect { raise ArgumentError, "bad" }.to raise_error(ArgumentError)
+      end
+    )
+  )
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+end
+
+test("resolves keyword fixture dependencies per test") do
+  calls = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :user do
+      calls << :user
+      "Alice"
+    end
+
+    fixture :greeting do |user:|
+      "Hello, #{user}"
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("first", proc { |greeting:| expect(greeting).to eq("Hello, Alice") }))
+  suite.tests.add(SmartestSelfTest.test_case("second", proc { |greeting:| expect(greeting).to eq("Hello, Alice") }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(calls).to eq(%i[user user])
+end
+
+test("creates fresh fixture values and fixture instances for each test") do
+  markers = []
+  instances = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :marker do
+      instances << self
+      Object.new
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("first", proc { |marker:| markers << marker }))
+  suite.tests.add(SmartestSelfTest.test_case("second", proc { |marker:| markers << marker }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(markers.length).to eq(2)
+  expect(markers[0].object_id).not_to eq(markers[1].object_id)
+  expect(instances.length).to eq(2)
+  expect(instances[0].object_id).not_to eq(instances[1].object_id)
+end
+
+test("caches fixture values within one test") do
+  calls = 0
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :token do
+      calls += 1
+      Object.new
+    end
+
+    fixture :first do |token:|
+      token
+    end
+
+    fixture :second do |token:|
+      token
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("same object", proc { |first:, second:| expect(first.object_id).to eq(second.object_id) }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(calls).to eq(1)
+end
+
+test("suite fixtures are created once and cleaned up after the suite") do
+  events = []
+  servers = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    suite_fixture :server do
+      events << :server_setup
+      server = Object.new
+      cleanup { events << :server_cleanup }
+      server
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("first", proc { |server:| events << :first; servers << server }))
+  suite.tests.add(SmartestSelfTest.test_case("second", proc { |server:| events << :second; servers << server }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(events).to eq(%i[server_setup first second server_cleanup])
+  expect(servers.length).to eq(2)
+  expect(servers[0].object_id).to eq(servers[1].object_id)
+end
+
+test("test fixtures can depend on suite fixtures") do
+  calls = []
+  server_ids = []
+  client_ids = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    suite_fixture :server do
+      calls << :server
+      Object.new
+    end
+
+    fixture :client do |server:|
+      [server, Object.new]
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("first", proc { |client:| server_ids << client.first.object_id; client_ids << client.last.object_id }))
+  suite.tests.add(SmartestSelfTest.test_case("second", proc { |client:| server_ids << client.first.object_id; client_ids << client.last.object_id }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+  expect(calls).to eq([:server])
+  expect(server_ids.uniq.length).to eq(1)
+  expect(client_ids.uniq.length).to eq(2)
+end
+
+test("suite fixtures cannot depend on test fixtures") do
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :user do
+      :user
+    end
+
+    suite_fixture :server do |user:|
+      user
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("needs server", proc { |server:| expect(server).to eq(:server) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("suite-scoped fixture server cannot depend on test-scoped fixture user")
+end
+
+test("suite fixture setup failures are cached and cleaned up once") do
+  calls = 0
+  events = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    suite_fixture :server do
+      calls += 1
+      cleanup { events << :server_cleanup }
+      raise "server setup failed"
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("first", proc { |server:| expect(server).to eq(:server) }))
+  suite.tests.add(SmartestSelfTest.test_case("second", proc { |server:| expect(server).to eq(:server) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(calls).to eq(1)
+  expect(events).to eq([:server_cleanup])
+  expect(output.scan("RuntimeError: server setup failed").length).to eq(2)
+end
+
+test("suite cleanup failures fail the run") do
+  fixture_class = Class.new(Smartest::Fixture) do
+    suite_fixture :browser do
+      cleanup { raise "browser close failed" }
+      :browser
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("uses browser", proc { |browser:| expect(browser).to eq(:browser) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("Suite cleanup failures:")
+  expect(output).to include("cleanup failed: RuntimeError: browser close failed")
+  expect(output).to include("1 test, 1 passed, 0 failed, 1 suite cleanup failed")
+end
+
+test("runs cleanup in reverse order after failures") do
+  events = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :server do
+      cleanup { events << :server }
+      :server
+    end
+
+    fixture :browser do |server:|
+      cleanup { events << :browser }
+      server
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("fails", proc { |browser:| expect(browser).to eq(:nope) }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(events).to eq(%i[browser server])
+end
+
+test("runs cleanup when fixture setup fails after cleanup registration") do
+  events = []
+
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :server do
+      cleanup { events << :server }
+      raise "server setup failed"
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("needs server", proc { |server:| expect(server).to eq(:server) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(events).to eq([:server])
+  expect(output).to include("RuntimeError: server setup failed")
+end
+
+test("duplicate fixture names fail the test") do
+  first_fixture = Class.new(Smartest::Fixture) do
+    fixture(:user) { "Alice" }
+  end
+
+  second_fixture = Class.new(Smartest::Fixture) do
+    fixture(:user) { "Bob" }
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(first_fixture)
+  suite.fixture_classes.add(second_fixture)
+  suite.tests.add(SmartestSelfTest.test_case("needs user", proc { |user:| expect(user).to eq("Alice") }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("duplicate fixture: user")
+end
+
+test("allows child fixture classes to override parent fixtures") do
+  parent_fixture = Class.new(Smartest::Fixture) do
+    fixture(:user_name) { "Parent" }
+  end
+
+  child_fixture = Class.new(parent_fixture) do
+    fixture(:user_name) { "Child" }
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(child_fixture)
+  suite.tests.add(SmartestSelfTest.test_case("uses override", proc { |user_name:| expect(user_name).to eq("Child") }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+end
+
+test("circular fixture dependencies fail the test") do
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture(:a) { |b:| b }
+    fixture(:b) { |a:| a }
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("cycle", proc { |a:| expect(a).to eq(:a) }))
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("circular fixture dependency: a -> b -> a")
+end
+
+test("fixture blocks can call private helper methods") do
+  fixture_class = Class.new(Smartest::Fixture) do
+    fixture :user_name do
+      build_user_name("Alice")
+    end
+
+    private
+
+    def build_user_name(name)
+      name.upcase
+    end
+  end
+
+  suite = Smartest::Suite.new
+  suite.fixture_classes.add(fixture_class)
+  suite.tests.add(SmartestSelfTest.test_case("uses helper", proc { |user_name:| expect(user_name).to eq("ALICE") }))
+
+  status, = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(0)
+end
+
+test("rejects positional test parameters") do
+  error = SmartestSelfTest.capture_error(Smartest::InvalidFixtureParameterError) do
+    SmartestSelfTest.test_case("bad", proc { |_user| nil })
+  end
+
+  expect(error.message).to include("Positional fixture parameters are not supported.")
+end
+
+test("rejects positional fixture parameters") do
+  error = SmartestSelfTest.capture_error(Smartest::InvalidFixtureParameterError) do
+    Class.new(Smartest::Fixture) do
+      fixture(:bad) { |_server| nil }
+    end
+  end
+
+  expect(error.message).to include("Positional fixture dependencies are not supported.")
+end
+
+test("rejects invalid fixture scopes") do
+  error = SmartestSelfTest.capture_error(Smartest::InvalidFixtureScopeError) do
+    Class.new(Smartest::Fixture) do
+      fixture(:bad, scope: :file) { nil }
+    end
+  end
+
+  expect(error.message).to include("invalid fixture scope: :file")
+  expect(error.message).to include("supported scopes: test, suite")
+end
+
+test("cli loads files and returns failure status") do
+  Dir.mktmpdir do |dir|
+    smartest_dir = File.join(dir, "smartest")
+    FileUtils.mkdir_p(smartest_dir)
+    File.write(File.join(smartest_dir, "test_helper.rb"), <<~RUBY)
+      require "smartest/autorun"
+    RUBY
+
+    test_file = File.join(smartest_dir, "sample_test.rb")
+    File.write(test_file, <<~RUBY)
+      require "test_helper"
+
+      test("cli failure") do
+        expect("a").to eq("b")
+      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 eq("")
+    expect(stdout).to include("cli failure")
+    expect(stdout).to include("expected \"a\" to eq \"b\"")
+  end
+end
+
+test("cli default suite ignores minitest-style test directory") do
+  Dir.mktmpdir do |dir|
+    smartest_dir = File.join(dir, "smartest")
+    FileUtils.mkdir_p(smartest_dir)
+    File.write(File.join(smartest_dir, "test_helper.rb"), <<~RUBY)
+      require "smartest/autorun"
+    RUBY
+
+    File.write(File.join(smartest_dir, "sample_test.rb"), <<~RUBY)
+      require "test_helper"
+
+      test("smartest default") do
+        expect(1).to eq(1)
+      end
+    RUBY
+
+    minitest_dir = File.join(dir, "test")
+    FileUtils.mkdir_p(minitest_dir)
+    File.write(File.join(minitest_dir, "test_helper.rb"), <<~RUBY)
+      raise "loaded minitest helper"
+    RUBY
+    File.write(File.join(minitest_dir, "sample_test.rb"), <<~RUBY)
+      raise "loaded minitest test"
+    RUBY
+
+    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(true)
+    expect(stderr).to eq("")
+    expect(stdout).to include("smartest default")
+    expect(stdout).to include("1 test, 1 passed, 0 failed")
+  end
+end
+
+test("cli prints version") do
+  stdout, stderr, status = Open3.capture3(
+    { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+    "ruby",
+    File.expand_path("../exe/smartest", __dir__),
+    "--version"
+  )
+
+  expect(status.success?).to eq(true)
+  expect(stderr).to eq("")
+  expect(stdout).to eq("#{Smartest::VERSION}\n")
+end
+
+test("cli prints help") do
+  stdout, stderr, status = Open3.capture3(
+    { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+    "ruby",
+    File.expand_path("../exe/smartest", __dir__),
+    "--help"
+  )
+
+  expect(status.success?).to eq(true)
+  expect(stderr).to eq("")
+  expect(stdout).to include("Usage:")
+  expect(stdout).to include("smartest [paths...]")
+  expect(stdout).to include("smartest --init")
+  expect(stdout).to include("smartest/**/*_test.rb")
+end
+
+test("cli initializes a runnable test scaffold") do
+  Dir.mktmpdir do |dir|
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      "--init",
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(true)
+    expect(stderr).to eq("")
+    expect(stdout).to include("create  smartest")
+    expect(stdout).to include("create  smartest/fixtures")
+    expect(stdout).to include("create  smartest/test_helper.rb")
+    expect(stdout).to include("create  smartest/example_test.rb")
+    helper_contents = File.read(File.join(dir, "smartest/test_helper.rb"))
+    expect(helper_contents).to include('require "smartest/autorun"')
+    expect(helper_contents).to include('Dir[File.join(__dir__, "fixtures", "**", "*.rb")].sort.each')
+    expect(File.read(File.join(dir, "smartest/example_test.rb"))).to include('require "test_helper"')
+
+    nested_fixtures_dir = File.join(dir, "smartest/fixtures/nested")
+    FileUtils.mkdir_p(nested_fixtures_dir)
+    File.write(File.join(nested_fixtures_dir, "auto_loaded_fixture.rb"), <<~RUBY)
+      class AutoLoadedFixture < Smartest::Fixture
+        fixture :auto_loaded_message do
+          "loaded from smartest/fixtures"
+        end
+      end
+    RUBY
+
+    File.write(File.join(dir, "smartest/auto_loaded_fixture_test.rb"), <<~RUBY)
+      require "test_helper"
+
+      use_fixture AutoLoadedFixture
+
+      test("auto-loaded fixture") do |auto_loaded_message:|
+        expect(auto_loaded_message).to eq("loaded from smartest/fixtures")
+      end
+    RUBY
+
+    run_stdout, run_stderr, run_status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      chdir: dir
+    )
+
+    expect(run_status.success?).to eq(true)
+    expect(run_stderr).to eq("")
+    expect(run_stdout).to include("example")
+    expect(run_stdout).to include("auto-loaded fixture")
+    expect(run_stdout).to include("2 tests, 2 passed, 0 failed")
+  end
+end
+
+test("cli init does not overwrite existing scaffold files") do
+  Dir.mktmpdir do |dir|
+    smartest_dir = File.join(dir, "smartest")
+    fixture_dir = File.join(smartest_dir, "fixtures")
+    FileUtils.mkdir_p(fixture_dir)
+    helper_path = File.join(smartest_dir, "test_helper.rb")
+    example_path = File.join(smartest_dir, "example_test.rb")
+    fixture_path = File.join(fixture_dir, "custom_fixture.rb")
+    File.write(helper_path, "# custom helper\n")
+    File.write(example_path, "# custom test\n")
+    File.write(fixture_path, "# custom fixture\n")
+
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      "--init",
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(true)
+    expect(stderr).to eq("")
+    expect(stdout).to include("exist   smartest")
+    expect(stdout).to include("exist   smartest/fixtures")
+    expect(stdout).to include("exist   smartest/test_helper.rb")
+    expect(stdout).to include("exist   smartest/example_test.rb")
+    expect(File.read(helper_path)).to eq("# custom helper\n")
+    expect(File.read(example_path)).to eq("# custom test\n")
+    expect(File.read(fixture_path)).to eq("# custom fixture\n")
+  end
+end

data/smartest.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "lib/smartest/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "smartest"
+  spec.version = Smartest::VERSION
+  spec.authors = ["Yusuke Iwaki"]
+
+  spec.summary = "A small Ruby test runner with keyword-first fixtures."
+  spec.description = "Smartest is a small Ruby test runner focused on readable top-level tests, explicit keyword-argument fixture dependencies, and optional fixture cleanup."
+  spec.homepage = "https://github.com/YusukeIwaki/smartest"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1"
+
+  spec.metadata = {
+    "allowed_push_host" => "https://rubygems.org",
+    "bug_tracker_uri" => "https://github.com/YusukeIwaki/smartest/issues",
+    "documentation_uri" => "https://smartest-rb.vercel.app/",
+    "homepage_uri" => spec.homepage,
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => "https://github.com/YusukeIwaki/smartest/tree/main"
+  }
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir.glob(
+      [
+        "CHANGELOG.md",
+        "DEVELOPMENT.md",
+        "Gemfile",
+        "LICENSE",
+        "README.md",
+        "Rakefile",
+        "SMARTEST_DESIGN.md",
+        "exe/*",
+        "lib/**/*.rb",
+        "smartest.gemspec",
+        "smartest/**/*.rb"
+      ]
+    )
+  end
+
+  spec.bindir = "exe"
+  spec.executables = ["smartest"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 13.0"
+end