smartest 0.1.0.alpha1

data/lib/smartest/reporter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Smartest
+  class Reporter
+    PASS_MARK = "\u2713"
+    FAIL_MARK = "\u2717"
+
+    def initialize(io = $stdout)
+      @io = io
+    end
+
+    def start(count)
+      @io.puts "Running #{count} #{count == 1 ? 'test' : 'tests'}"
+      @io.puts
+    end
+
+    def record(result)
+      mark = result.passed? ? PASS_MARK : FAIL_MARK
+      @io.puts "#{mark} #{result.test_case.name}"
+    end
+
+    def finish(results, suite_cleanup_errors: [])
+      failures = results.select(&:failed?)
+
+      report_failures(failures) if failures.any?
+      report_suite_cleanup_errors(suite_cleanup_errors) if suite_cleanup_errors.any?
+
+      @io.puts
+      summary = "#{results.count} #{results.count == 1 ? 'test' : 'tests'}, #{results.count(&:passed?)} passed, #{failures.count} failed"
+      if suite_cleanup_errors.any?
+        cleanup_label = suite_cleanup_errors.count == 1 ? "suite cleanup" : "suite cleanups"
+        summary = "#{summary}, #{suite_cleanup_errors.count} #{cleanup_label} failed"
+      end
+      @io.puts summary
+    end
+
+    private
+
+    def report_failures(failures)
+      @io.puts
+      @io.puts "Failures:"
+      @io.puts
+
+      failures.each_with_index do |result, index|
+        @io.puts "#{index + 1}) #{result.test_case.name}"
+        report_location(result.test_case.location)
+        report_error(result.error) if result.error
+        result.cleanup_errors.each { |error| report_cleanup_error(error) }
+        @io.puts
+      end
+    end
+
+    def report_suite_cleanup_errors(errors)
+      @io.puts
+      @io.puts "Suite cleanup failures:"
+      @io.puts
+
+      errors.each_with_index do |error, index|
+        @io.puts "#{index + 1}) suite cleanup"
+        report_cleanup_error(error)
+        @io.puts
+      end
+    end
+
+    def report_location(location)
+      return unless location
+
+      @io.puts "   #{location.path}:#{location.lineno}"
+    end
+
+    def report_error(error)
+      if error.is_a?(AssertionFailed)
+        @io.puts "   #{error.message}"
+      else
+        @io.puts "   #{error.class}: #{error.message}"
+      end
+
+      report_backtrace(error)
+    end
+
+    def report_cleanup_error(error)
+      @io.puts "   cleanup failed: #{error.class}: #{error.message}"
+      report_backtrace(error)
+    end
+
+    def report_backtrace(error)
+      backtrace_line = error.backtrace&.first
+      @io.puts "   #{backtrace_line}" if backtrace_line
+    end
+  end
+end

data/lib/smartest/runner.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Smartest
+  class Runner
+    def initialize(suite: Smartest.suite, reporter: Reporter.new)
+      @suite = suite
+      @reporter = reporter
+    end
+
+    def run
+      results = []
+      suite_cleanup_errors = []
+      @suite_fixture_set = nil
+
+      @reporter.start(@suite.tests.count)
+
+      begin
+        @suite.tests.each do |test_case|
+          result = run_one(test_case)
+          results << result
+          @reporter.record(result)
+        end
+      ensure
+        suite_cleanup_errors = @suite_fixture_set.run_cleanups if @suite_fixture_set
+        @suite_fixture_set = nil
+      end
+
+      @reporter.finish(results, suite_cleanup_errors: suite_cleanup_errors)
+
+      results.any?(&:failed?) || suite_cleanup_errors.any? ? 1 : 0
+    end
+
+    private
+
+    def run_one(test_case)
+      started_at = now
+      context = ExecutionContext.new
+      fixture_set = nil
+      error = nil
+      cleanup_errors = []
+
+      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)
+      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
+
+      if error || cleanup_errors.any?
+        TestResult.failed(
+          test_case: test_case,
+          error: error,
+          duration: duration,
+          cleanup_errors: cleanup_errors
+        )
+      else
+        TestResult.passed(test_case: test_case, duration: duration)
+      end
+    end
+
+    def suite_fixture_set
+      @suite_fixture_set ||= FixtureSet.new(
+        @suite.fixture_classes,
+        context: ExecutionContext.new,
+        scope: :suite
+      )
+    end
+
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/smartest/suite.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Smartest
+  class Suite
+    attr_reader :tests, :fixture_classes
+
+    def initialize
+      @tests = TestRegistry.new
+      @fixture_classes = FixtureClassRegistry.new
+    end
+  end
+end

data/lib/smartest/test_case.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smartest
+  class TestCase
+    attr_reader :name, :metadata, :block, :location, :fixture_names
+
+    def initialize(name:, metadata:, block:, location:)
+      raise ArgumentError, "test name is required" if name.nil? || name.to_s.empty?
+      raise ArgumentError, "test block is required" unless block
+
+      @name = name.to_s
+      @metadata = metadata
+      @block = block
+      @location = location
+      @fixture_names = ParameterExtractor.required_keyword_names(block, usage: :test)
+    end
+  end
+end

data/lib/smartest/test_registry.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Smartest
+  class TestRegistry
+    include Enumerable
+
+    def initialize
+      @tests = []
+    end
+
+    def add(test_case)
+      @tests << test_case
+    end
+
+    def each(&block)
+      @tests.each(&block)
+    end
+
+    def count
+      @tests.count
+    end
+
+    alias size count
+  end
+end

data/lib/smartest/test_result.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Smartest
+  class TestResult
+    attr_reader :test_case, :status, :error, :duration, :cleanup_errors
+
+    def self.passed(test_case:, duration:, cleanup_errors: [])
+      new(
+        test_case: test_case,
+        status: :passed,
+        error: nil,
+        duration: duration,
+        cleanup_errors: cleanup_errors
+      )
+    end
+
+    def self.failed(test_case:, error:, duration:, cleanup_errors: [])
+      new(
+        test_case: test_case,
+        status: :failed,
+        error: error,
+        duration: duration,
+        cleanup_errors: cleanup_errors
+      )
+    end
+
+    def initialize(test_case:, status:, error:, duration:, cleanup_errors:)
+      @test_case = test_case
+      @status = status
+      @error = error
+      @duration = duration
+      @cleanup_errors = cleanup_errors
+    end
+
+    def passed?
+      status == :passed
+    end
+
+    def failed?
+      status == :failed
+    end
+  end
+end

data/lib/smartest/version.rb

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

data/lib/smartest.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "smartest/version"
+require_relative "smartest/errors"
+require_relative "smartest/parameter_extractor"
+require_relative "smartest/test_case"
+require_relative "smartest/test_registry"
+require_relative "smartest/fixture_definition"
+require_relative "smartest/fixture"
+require_relative "smartest/fixture_class_registry"
+require_relative "smartest/fixture_set"
+require_relative "smartest/suite"
+require_relative "smartest/expectations"
+require_relative "smartest/expectation_target"
+require_relative "smartest/matchers"
+require_relative "smartest/execution_context"
+require_relative "smartest/dsl"
+require_relative "smartest/test_result"
+require_relative "smartest/reporter"
+require_relative "smartest/runner"
+require_relative "smartest/init_generator"
+
+module Smartest
+  class << self
+    def suite
+      @suite ||= Suite.new
+    end
+
+    def reset!
+      @suite = Suite.new
+    end
+
+    def disable_autorun!
+      @autorun_disabled = true
+    end
+
+    def autorun_disabled?
+      @autorun_disabled == true
+    end
+
+    def register_autorun!
+      return if autorun_disabled?
+      return if @autorun_registered
+
+      @autorun_registered = true
+
+      at_exit do
+        exit Runner.new.run if $ERROR_INFO.nil?
+      end
+    end
+
+    def fatal_exception?(error)
+      error.is_a?(SystemExit) ||
+        error.is_a?(Interrupt) ||
+        error.is_a?(SignalException) ||
+        error.is_a?(NoMemoryError)
+    end
+  end
+end