smartest 0.1.0.alpha1

data/exe/smartest

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "smartest"
+
+usage = <<~USAGE
+  Usage:
+    smartest [paths...]
+    smartest --init
+    smartest --version
+    smartest --help
+
+  When no paths are given, Smartest loads smartest/**/*_test.rb.
+USAGE
+
+command = :run
+
+begin
+  if ARGV.include?("--help") || ARGV.include?("-h")
+    puts usage
+    exit 0
+  end
+
+  if ARGV.include?("--version") || ARGV.include?("-v")
+    puts Smartest::VERSION
+    exit 0
+  end
+
+  if ARGV.include?("--init")
+    command = :init
+    exit Smartest::InitGenerator.new.run
+  end
+
+  Smartest.disable_autorun!
+  Kernel.prepend Smartest::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)
+
+  files =
+    if ARGV.empty?
+      Dir["smartest/**/*_test.rb"]
+    else
+      ARGV.flat_map do |pattern|
+        matches = Dir[pattern]
+        matches.empty? ? [pattern] : matches
+      end.uniq
+    end
+
+  files.each do |file|
+    load File.expand_path(file)
+  end
+
+  exit Smartest::Runner.new.run
+rescue Exception => error
+  raise if Smartest.fatal_exception?(error)
+
+  warn(command == :init ? "Error initializing Smartest:" : "Error loading tests:")
+  warn "#{error.class}: #{error.message}"
+  warn error.backtrace&.first
+  exit 1
+end

data/lib/smartest/autorun.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "English"
+require_relative "../smartest"
+
+Kernel.prepend Smartest::DSL
+
+Smartest.register_autorun!

data/lib/smartest/dsl.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Smartest
+  module DSL
+    def test(name, **metadata, &block)
+      Smartest.suite.tests.add(
+        TestCase.new(
+          name: name,
+          metadata: metadata,
+          block: block,
+          location: caller_locations(1, 1).first
+        )
+      )
+    end
+
+    def use_fixture(klass)
+      Smartest.suite.fixture_classes.add(klass)
+    end
+
+    private :test, :use_fixture
+  end
+end

data/lib/smartest/errors.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Smartest
+  class Error < StandardError; end
+
+  class FixtureNotFoundError < Error
+    def initialize(name)
+      super("fixture not found: #{name}")
+    end
+  end
+
+  class DuplicateFixtureError < Error
+    def initialize(name, fixture_classes)
+      class_names = fixture_classes.map { |klass| klass.name || klass.inspect }
+
+      super(<<~MESSAGE.chomp)
+        duplicate fixture: #{name}
+        defined in:
+        #{class_names.map { |class_name| "  #{class_name}" }.join("\n")}
+      MESSAGE
+    end
+  end
+
+  class CircularFixtureDependencyError < Error
+    def initialize(path)
+      super("circular fixture dependency: #{path.join(' -> ')}")
+    end
+  end
+
+  class InvalidFixtureScopeError < Error
+    def initialize(scope)
+      super("invalid fixture scope: #{scope.inspect}; supported scopes: test, suite")
+    end
+  end
+
+  class InvalidFixtureScopeDependencyError < Error
+    def initialize(dependent_name:, dependent_scope:, dependency_name:, dependency_scope:)
+      message =
+        if dependent_name
+          "#{dependent_scope}-scoped fixture #{dependent_name} cannot depend on #{dependency_scope}-scoped fixture #{dependency_name}"
+        else
+          "cannot resolve #{dependency_scope}-scoped fixture #{dependency_name} from #{dependent_scope} fixture scope"
+        end
+
+      super(message)
+    end
+  end
+
+  class InvalidFixtureParameterError < Error; end
+
+  class AssertionFailed < Error; end
+end

data/lib/smartest/execution_context.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Smartest
+  class ExecutionContext
+    include Expectations
+    include Matchers
+  end
+end

data/lib/smartest/expectation_target.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Smartest
+  class ExpectationTarget
+    def initialize(actual)
+      @actual = actual
+    end
+
+    def to(matcher)
+      return self if matcher.matches?(@actual)
+
+      raise AssertionFailed, matcher.failure_message
+    end
+
+    def not_to(matcher)
+      return self unless matcher.matches?(@actual)
+
+      raise AssertionFailed, matcher.negated_failure_message
+    end
+  end
+end

data/lib/smartest/expectations.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Smartest
+  module Expectations
+    def expect(actual = nil, &block)
+      ExpectationTarget.new(block || actual)
+    end
+  end
+end

data/lib/smartest/fixture.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Smartest
+  class Fixture
+    class << self
+      def fixture(name, scope: :test, &block)
+        define_fixture(
+          name,
+          scope: scope,
+          block: block,
+          location: caller_locations(1, 1).first
+        )
+      end
+
+      def suite_fixture(name, &block)
+        define_fixture(
+          name,
+          scope: :suite,
+          block: block,
+          location: caller_locations(1, 1).first
+        )
+      end
+
+      def fixture_definitions
+        inherited =
+          if superclass.respond_to?(:fixture_definitions)
+            superclass.fixture_definitions
+          else
+            {}
+          end
+
+        inherited.merge(own_fixture_definitions)
+      end
+
+      private
+
+      def define_fixture(name, scope:, block:, location:)
+        definition = FixtureDefinition.new(
+          name: name,
+          block: block,
+          location: location,
+          scope: scope
+        )
+
+        own_fixture_definitions[definition.name] = definition
+      end
+
+      def own_fixture_definitions
+        @fixture_definitions ||= {}
+      end
+    end
+
+    def initialize(fixture_set:, context:)
+      @fixture_set = fixture_set
+      @context = context
+    end
+
+    private
+
+    def cleanup(&block)
+      raise ArgumentError, "cleanup block is required" unless block
+
+      @fixture_set.add_cleanup(&block)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @context.respond_to?(method_name, true)
+        @context.__send__(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @context.respond_to?(method_name, true) || super
+    end
+  end
+end

data/lib/smartest/fixture_class_registry.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Smartest
+  class FixtureClassRegistry
+    include Enumerable
+
+    def initialize
+      @fixture_classes = []
+    end
+
+    def add(klass)
+      unless klass.is_a?(Class) && klass <= Fixture
+        raise ArgumentError, "fixture class must inherit from Smartest::Fixture"
+      end
+
+      @fixture_classes << klass unless @fixture_classes.include?(klass)
+    end
+
+    def each(&block)
+      @fixture_classes.each(&block)
+    end
+
+    def to_a
+      @fixture_classes.dup
+    end
+  end
+end

data/lib/smartest/fixture_definition.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Smartest
+  class FixtureDefinition
+    VALID_SCOPES = %i[test suite].freeze
+
+    attr_reader :name, :block, :dependencies, :location, :scope
+
+    def initialize(name:, block:, location:, scope: :test)
+      raise ArgumentError, "fixture name is required" if name.nil? || name.to_s.empty?
+      raise ArgumentError, "fixture block is required" unless block
+
+      @name = name.to_sym
+      @block = block
+      @location = location
+      @scope = normalize_scope(scope)
+      @dependencies = ParameterExtractor.required_keyword_names(block, usage: :fixture)
+    end
+
+    private
+
+    def normalize_scope(scope)
+      symbol_scope = scope.to_sym
+      return symbol_scope if VALID_SCOPES.include?(symbol_scope)
+
+      raise InvalidFixtureScopeError, scope
+    rescue NoMethodError
+      raise InvalidFixtureScopeError, scope
+    end
+  end
+end

data/lib/smartest/fixture_set.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Smartest
+  class FixtureSet
+    def initialize(fixture_classes, context:, scope: :test, parent: nil)
+      @fixture_classes = fixture_classes.to_a
+      @context = context
+      @scope = normalize_scope(scope)
+      @parent = parent
+      @cache = {}
+      @setup_errors = {}
+      @cleanups = []
+      @resolving = []
+
+      build_fixture_index
+    end
+
+    def resolve_keywords(names)
+      names.to_h do |name|
+        symbol_name = name.to_sym
+        [symbol_name, resolve(symbol_name)]
+      end
+    end
+
+    def resolve(name)
+      symbol_name = name.to_sym
+
+      if @resolving.include?(symbol_name)
+        cycle_start = @resolving.index(symbol_name)
+        raise CircularFixtureDependencyError, @resolving[cycle_start..] + [symbol_name]
+      end
+
+      definition = @definitions[symbol_name]
+      raise FixtureNotFoundError, symbol_name unless definition
+
+      return resolve_from_parent(symbol_name, definition) unless definition.scope == @scope
+      return @cache[symbol_name] if @cache.key?(symbol_name)
+      raise @setup_errors[symbol_name] if @setup_errors.key?(symbol_name)
+
+      @resolving << symbol_name
+      dependencies = resolve_keywords(definition.dependencies)
+      @cache[symbol_name] = @instances[symbol_name].instance_exec(**dependencies, &definition.block)
+    rescue Exception => error
+      raise if Smartest.fatal_exception?(error)
+
+      @setup_errors[symbol_name] = error if definition&.scope == @scope
+      raise
+    ensure
+      @resolving.pop if @resolving.last == symbol_name
+    end
+
+    def add_cleanup(&block)
+      raise ArgumentError, "cleanup block is required" unless block
+
+      @cleanups << block
+    end
+
+    def run_cleanups
+      errors = []
+
+      @cleanups.reverse_each do |cleanup|
+        cleanup.call
+      rescue Exception => error
+        raise if Smartest.fatal_exception?(error)
+
+        errors << error
+      end
+
+      errors
+    end
+
+    private
+
+    def normalize_scope(scope)
+      symbol_scope = scope.to_sym
+      return symbol_scope if FixtureDefinition::VALID_SCOPES.include?(symbol_scope)
+
+      raise InvalidFixtureScopeError, scope
+    rescue NoMethodError
+      raise InvalidFixtureScopeError, scope
+    end
+
+    def resolve_from_parent(name, definition)
+      return @parent.resolve(name) if @parent && definition.scope == :suite
+
+      raise InvalidFixtureScopeDependencyError.new(
+        dependent_name: @resolving.last,
+        dependent_scope: @scope,
+        dependency_name: name,
+        dependency_scope: definition.scope
+      )
+    end
+
+    def build_fixture_index
+      definitions_by_name = Hash.new { |hash, key| hash[key] = [] }
+      instances_by_class = {}
+
+      @fixture_classes.each do |fixture_class|
+        instances_by_class[fixture_class] = fixture_class.new(fixture_set: self, context: @context)
+
+        fixture_class.fixture_definitions.each_value do |definition|
+          definitions_by_name[definition.name] << [fixture_class, definition]
+        end
+      end
+
+      duplicate = definitions_by_name.find { |_name, entries| entries.length > 1 }
+      raise DuplicateFixtureError.new(duplicate.first, duplicate.last.map(&:first)) if duplicate
+
+      @definitions = {}
+      @instances = {}
+
+      definitions_by_name.each do |name, entries|
+        fixture_class, definition = entries.first
+        @definitions[name] = definition
+        @instances[name] = instances_by_class[fixture_class]
+      end
+    end
+  end
+end

data/lib/smartest/init_generator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Smartest
+  class InitGenerator
+    FILES = {
+      "smartest/test_helper.rb" => <<~RUBY,
+        # frozen_string_literal: true
+
+        require "smartest/autorun"
+
+        Dir[File.join(__dir__, "fixtures", "**", "*.rb")].sort.each do |fixture_file|
+          require fixture_file
+        end
+      RUBY
+      "smartest/example_test.rb" => <<~RUBY
+        # frozen_string_literal: true
+
+        require "test_helper"
+
+        test("example") do
+          expect(1 + 1).to eq(2)
+        end
+      RUBY
+    }.freeze
+
+    def initialize(root: Dir.pwd, output: $stdout)
+      @root = root
+      @output = output
+    end
+
+    def run
+      create_directory("smartest")
+      create_directory("smartest/fixtures")
+      FILES.each { |path, contents| create_file(path, contents) }
+
+      @output.puts
+      @output.puts "Run your test suite with: bundle exec smartest"
+
+      0
+    end
+
+    private
+
+    def create_directory(path)
+      absolute_path = File.join(@root, path)
+
+      if Dir.exist?(absolute_path)
+        @output.puts "exist   #{path}"
+        return
+      end
+
+      FileUtils.mkdir_p(absolute_path)
+      @output.puts "create  #{path}"
+    end
+
+    def create_file(path, contents)
+      absolute_path = File.join(@root, path)
+
+      if File.exist?(absolute_path)
+        @output.puts "exist   #{path}"
+        return
+      end
+
+      File.write(absolute_path, contents)
+      @output.puts "create  #{path}"
+    end
+  end
+end

data/lib/smartest/matchers.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Smartest
+  module Matchers
+    def eq(expected)
+      EqMatcher.new(expected)
+    end
+
+    def include(expected)
+      IncludeMatcher.new(expected)
+    end
+
+    def be_nil
+      BeNilMatcher.new
+    end
+
+    def raise_error(expected_error = StandardError)
+      RaiseErrorMatcher.new(expected_error)
+    end
+  end
+
+  class EqMatcher
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(actual)
+      @actual = actual
+      actual == @expected
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to eq #{@expected.inspect}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to eq #{@expected.inspect}"
+    end
+  end
+
+  class IncludeMatcher
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(actual)
+      @actual = actual
+      actual.include?(@expected)
+    rescue NoMethodError
+      false
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to include #{@expected.inspect}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to include #{@expected.inspect}"
+    end
+  end
+
+  class BeNilMatcher
+    def matches?(actual)
+      @actual = actual
+      actual.nil?
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to be nil"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to be nil"
+    end
+  end
+
+  class RaiseErrorMatcher
+    def initialize(expected_error)
+      @expected_error = expected_error
+      @actual_error = nil
+      @callable = true
+    end
+
+    def matches?(actual)
+      @actual_error = nil
+      @callable = actual.respond_to?(:call)
+      return false unless @callable
+
+      actual.call
+      false
+    rescue Exception => error
+      raise if Smartest.fatal_exception?(error)
+
+      @actual_error = error
+      error.is_a?(@expected_error)
+    end
+
+    def failure_message
+      return "expected a block to raise #{@expected_error}" unless @callable
+      return "expected block to raise #{@expected_error}, but nothing was raised" unless @actual_error
+
+      "expected block to raise #{@expected_error}, but raised #{@actual_error.class}: #{@actual_error.message}"
+    end
+
+    def negated_failure_message
+      "expected block not to raise #{@expected_error}, but raised #{@actual_error.class}: #{@actual_error.message}"
+    end
+  end
+end

data/lib/smartest/parameter_extractor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Smartest
+  class ParameterExtractor
+    POSITIONAL_PARAMETER_TYPES = %i[req opt rest].freeze
+
+    class << self
+      def required_keyword_names(block, usage:)
+        raise ArgumentError, "block is required" unless block
+
+        parameters = block.parameters
+        positional = parameters.select { |type, _name| POSITIONAL_PARAMETER_TYPES.include?(type) }
+
+        raise InvalidFixtureParameterError, positional_parameter_message(usage) if positional.any?
+
+        parameters.filter_map do |type, name|
+          name if type == :keyreq
+        end
+      end
+
+      private
+
+      def positional_parameter_message(usage)
+        case usage
+        when :test
+          <<~MESSAGE.chomp
+            Positional fixture parameters are not supported.
+
+            Use keyword fixture injection:
+
+              test("bad") do |user:|
+                ...
+              end
+          MESSAGE
+        when :fixture
+          <<~MESSAGE.chomp
+            Positional fixture dependencies are not supported.
+
+            Use keyword fixture dependencies:
+
+              fixture :client do |server:|
+                ...
+              end
+          MESSAGE
+        else
+          "Positional fixture parameters are not supported."
+        end
+      end
+    end
+  end
+end