cake-tester 0.2.0

data/lib/contextual/test.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative '../test_failure'
+require_relative '../test_neutral'
+require_relative '../test_pass'
+require_relative 'context'
+require_relative 'node'
+require_relative 'child'
+
+# A Test is an actionable unit of testing.
+class Test < Contextual::Node
+  include Contextual::Child
+  # @return [Boolean]
+  attr_reader :ran_successfully
+
+  # @param title [String]
+  # @param assertions [Proc]
+  # @param action [Proc]
+  # @param skip [Boolean]
+  # @param options [TestOptions]
+  def initialize(
+    title,
+    assertions:,
+    setup: nil,
+    teardown: nil,
+    action: nil,
+    options: nil,
+    skip: false
+  )
+    super(title, setup: setup, teardown: teardown, options: options, skip: skip)
+    @action = action
+    @assertions = assertions
+    @assert_failures = []
+  end
+
+  def ran_successfully=(value)
+    # Once this has failed, don't allow it to recover
+    return if @ran_successfully == false
+
+    @ran_successfully = value
+  end
+
+  # Should this run with the current filter settings
+  # @param filter_settings [FilterSettings]
+  # @return [Boolean]
+  def should_run_with_filter(filter_settings)
+    return filter_settings.testSearchFor == _title if filter_settings.hasTestSearchFor
+    return _title.include? filter_settings.testFilterTerm if filter_settings.hasTestFilterTerm
+
+    should_run_with_search_term(filter_settings)
+  end
+
+  # Report results, if any
+  # @return [void]
+  def report(*)
+    @result.report(@parent_count)
+
+    @assert_failures.each do |assert_failure|
+      assert_failure.report(@parent_count)
+    end
+  end
+
+  # @param filter_settings [FilterSettings]
+  # @return [TestResult]
+  def get_result(filter_settings)
+    super
+
+    @result = run_setup
+
+    unless @result.nil?
+      # Setup failed, we want to bail out as soon as possible
+      @ran_successfully = false
+      return @result
+    end
+
+    run_action
+
+    run_assertions
+
+    teardown_failure = run_teardown
+    unless teardown_failure.nil?
+      @ran_successfully = false
+      @result = teardown_failure
+    end
+
+    # At this point, if nothing has failed, this test ran successfully
+    @ran_successfully = true if @ran_successfully.nil?
+    @result
+  end
+
+  private
+
+  def run_action
+    return if @action.nil?
+
+    begin
+      value = @action.call(@context)
+      @context.actual = value unless value.nil?
+    rescue StandardError => e
+      @ran_successfully = false
+      # We want to continue and try to teardown anything we've set up
+      # even if it's all haywire at this point
+      @result = TestFailure.new(@title, 'Failed during action', e)
+    end
+  end
+
+  # @return [TestResult]
+  def run_assertions
+    # Don't bother running assertions if we've already come up failed
+    return unless @result.nil?
+
+    asserts = @assertions.call(@context)
+    has_failed_a_test = false
+    assert_result = nil
+
+    asserts.each_with_index do |expect, index|
+      # Skip rest of assertions if an assert has failed already,
+      # allowing a bypass with an option flag.
+      if has_failed_a_test && @options.fail_on_first_expect
+        assert_result = AssertNeutral.new(
+          'Skipped: Previous assert failed.',
+          index
+        )
+        @assert_failures << assert_result
+        next
+      end
+
+      begin
+        assert_result = expect.run
+      rescue StandardError => e
+        assert_result = TestFailure.new(
+          @title,
+          'Failed while running assertions',
+          e
+        )
+      end
+
+      next unless assert_result.instance_of? AssertFailure
+
+      assert_result.index = index if asserts.length > 1
+      @assert_failures << assert_result
+      has_failed_a_test = true
+    end
+
+    @result = if @assert_failures.empty?
+                TestPass.new(@title)
+              else
+                TestFailure.new(@title, 'Assert failed.')
+              end
+  end
+end

data/lib/contextual/test_runner.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/filter_settings'
+require_relative '../helpers/printer'
+require_relative 'node'
+require_relative 'parent'
+
+# TestRunner
+#
+# @param title
+# @param context_builder
+# @param children
+# @param options
+# @param skip
+#
+# The root node for any tests. Automatically runs once created. Do not include
+# TestRunners inside other Groups.
+class TestRunner < Contextual::Node
+  include Contextual::Parent
+
+  def initialize(
+    title,
+    children = [],
+    setup: nil,
+    teardown: nil,
+    options: nil,
+    skip: false
+  )
+    super(title, setup: setup, teardown: teardown, options: options, skip: skip)
+    set_parent(children)
+    # TODO: Fetch filter settings
+    @filter_settings = FilterSettings.new
+    run_all
+  end
+
+  private
+
+  def run_all
+    return if skip
+
+    return unless should_run_with_filter(@filter_settings)
+
+    run(@context, @filter_settings)
+    report(@filter_settings)
+  end
+
+  # @param filter_settings [FilterSettings]
+  def should_run_with_filter(filter_settings)
+    return @title == filter_settings.test_runner_search_for if filter_settings.has_test_runner_search_for
+    return @title.include? filter_settings.test_runner_filter_term if filter_settings.has_test_runner_filter_term
+
+    should_run_with_search_term_with_children(filter_settings)
+    true
+  end
+
+  def report(filter_settings)
+    @result.report
+    return if @skip
+
+    report_children(filter_settings)
+
+    # Get count of successes, failures, and neutrals
+    message = Printer.summary(total, successes, failures, neutrals)
+
+    Printer.pass(message) if @result.instance_of? TestPass
+
+    Printer.fail(message) if @result.instance_of? TestFailure
+
+    Printer.neutral(message) if @result.instance_of? TestNeutral
+  end
+end

data/lib/expect.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Contains expects in order to run assertions in a [#Test]
+module Expect
+  # @abstract Base class for Expects. Override {#run} to implement the
+  #   validation logic.
+  class ExpectBase
+    attr_accessor :actual, :expected
+
+    # @param [Object] actual
+    # @param [Object] expected
+    def initialize(actual:, expected: nil)
+      @actual = actual
+      @expected = expected
+    end
+
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      AssertFailure.new("No expectation defined for #{@actual}.")
+    end
+  end
+
+  # Checks if actual == expected
+  class Equals < ExpectBase
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      return AssertPass.new if @actual == @expected
+
+      @actual = @actual.nil? ? '<nil>' : @actual
+      @expected = @expected.nil? ? '<nil>' : @expected
+      AssertFailure.new("Equality failed: Expected #{@expected}, got #{@actual}.")
+    end
+  end
+
+  # Checks if actual != expected
+  class IsNotEqual < ExpectBase
+    def initialize(actual:, not_expected:)
+      super(actual: actual, expected: not_expected)
+    end
+
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      return AssertPass.new if @actual != @expected
+
+      @actual = @actual.nil? ? '<nil>' : @actual
+      @expected = @expected.nil? ? '<nil>' : @expected
+      AssertFailure.new("Inequality failed: Expected #{@expected} to not equal #{@actual}.")
+    end
+  end
+
+  # Checks if actual is nil
+  class IsNil < ExpectBase
+    def initialize(actual)
+      super(actual: actual)
+    end
+
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      return AssertPass.new if @actual.nil?
+
+      AssertFailure.new("IsNil failed: Expected #{@actual} to be nil.")
+    end
+  end
+
+  # Checks if actual is not nil
+  class IsNotNil < ExpectBase
+    def initialize(actual)
+      super(actual: actual)
+    end
+
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      return AssertPass.new unless @actual.nil?
+
+      AssertFailure.new("IsNotNil failed: Expected #{@actual} to not be nil.")
+    end
+  end
+
+  # Checks if actual is truthy
+  class IsTrue < ExpectBase
+    def initialize(actual)
+      super(actual: actual)
+    end
+
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      return AssertPass.new if @actual
+
+      @actual = @actual.nil? ? '<nil>' : @actual
+      AssertFailure.new("IsTrue failed: Expected #{@actual} to be true.")
+    end
+  end
+
+  # Checks if actual is falsey
+  class IsFalse < ExpectBase
+    def initialize(actual)
+      super(actual: actual, expected: true)
+    end
+
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      return AssertPass.new unless @actual
+
+      AssertFailure.new("IsFalse failed: Expected #{@actual} to be false.")
+    end
+  end
+
+  # Checks if actual responds to a method
+  class RespondTo < ExpectBase
+    def initialize(actual, method)
+      super(actual: actual)
+      @method = method
+    end
+
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      return AssertPass.new if @actual.respond_to?(@method)
+
+      @actual = @actual.nil? ? '<nil>' : @actual
+      AssertFailure.new("RespondsTo failed: Expected #{@actual} to respond to #{@method}.")
+    end
+  end
+
+  # Checks if actual does not respond to a method
+  class Undefined < ExpectBase
+    def initialize(actual, method)
+      super(actual: actual)
+      @method = method
+    end
+
+    # Runs the validator and returns an AssertResult
+    # @return [AssertPass, AssertFailure]
+    def run
+      return AssertPass.new unless @actual.methods.include?(@method)
+
+      @actual = @actual.nil? ? '<nil>' : @actual
+      AssertFailure.new("Undefined failed: Expected #{@actual} to not respond to #{@method}.")
+    end
+  end
+
+  # Checks if actual does not respond to a method
+  # Synonym for Expect::Undefined
+  # @note (see Expect::Undefined)
+  class DoesNotRespondTo < Undefined
+  end
+end

data/lib/helpers/filter_settings.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# Holds a collection of filter settings. Filter settings are normally set via
+# the command line as flag options.
+class FilterSettings
+  def initialize(
+    general_search_term: nil,
+    test_filter_term: nil,
+    test_search_for: nil,
+    group_filter_term: nil,
+    group_search_for: nil,
+    test_runner_filter_term: nil,
+    test_runner_search_for: nil
+  )
+    @general_search_term = general_search_term || get_from_args(FilterProps::GENERAL_SEARCH_TERM)
+    @test_filter_term = test_filter_term || get_from_args(FilterProps::TEST_FILTER_TERM)
+    @test_search_for = test_search_for || get_from_args(FilterProps::TEST_SEARCH_FOR)
+    @group_filter_term = group_filter_term || get_from_args(FilterProps::GROUP_FILTER_TERM)
+    @group_search_for = group_search_for || get_from_args(FilterProps::GROUP_SEARCH_FOR)
+    @test_runner_filter_term = test_runner_filter_term || get_from_args(FilterProps::TEST_RUNNER_FILTER_TERM)
+    @test_runner_search_for = test_runner_search_for || get_from_args(FilterProps::TEST_RUNNER_SEARCH_FOR)
+  end
+
+  def has_general_search_term
+    !@general_search_term.nil? && @general_search_term.length.positive?
+  end
+
+  def has_test_filter_term
+    !@test_filter_term.nil? && @test_filter_term.length.positive?
+  end
+
+  def has_test_search_for
+    !@test_search_for.nil? && @test_search_for.length.positive?
+  end
+
+  def has_group_filter_term
+    !@group_filter_term.nil? && @group_filter_term.length.positive?
+  end
+
+  def has_group_search_for
+    !@group_search_for.nil? && @group_search_for.length.positive?
+  end
+
+  def has_test_runner_filter_term
+    !@test_runner_filter_term.nil? && @test_runner_filter_term.length.positive?
+  end
+
+  def has_test_runner_search_for
+    !@test_runner_search_for.nil? && @test_runner_search_for.length.positive?
+  end
+
+  def is_not_empty
+    hasGeneralSearchTerm ||
+      hasTestFilterTerm ||
+      hasTestSearchFor ||
+      hasGroupFilterTerm ||
+      hasGroupSearchFor ||
+      hasTestRunnerFilterTerm ||
+      hasTestRunnerSearchFor
+  end
+
+  def to_properties
+    props = []
+
+    props << [FilterProps::GENERAL_SEARCH_TERM, @general_search_term] if has_general_search_term
+    props << [FilterProps::TEST_FILTER_TERM, @test_filter_term] if has_test_filter_term
+    props << [FilterProps::TEST_SEARCH_FOR, @test_search_for] if has_test_search_for
+    props << [FilterProps::GROUP_FILTER_TERM, @group_filter_term] if has_group_filter_term
+    props << [FilterProps::GROUP_SEARCH_FOR, @group_search_for] if has_group_search_for
+    props << [FilterProps::TEST_RUNNER_FILTER_TERM, @test_runner_filter_term] if has_test_runner_filter_term
+    props << [FilterProps::TEST_RUNNER_SEARCH_FOR, @test_runner_search_for] if has_test_runner_search_for
+
+    props
+  end
+
+  # @param [String] flag
+  # @return [String, Nil]
+  def get_from_args(flag)
+    index = ARGV.find_index(flag)
+    return ARGV[index + 1] if index && index != ARGV.length - 1
+
+    nil
+  end
+end
+
+module FilterProps
+  GENERAL_SEARCH_TERM = 'generalSearchTerm'
+  TEST_FILTER_TERM = 'testFilterTerm'
+  TEST_SEARCH_FOR = 'testSearchFor'
+  GROUP_FILTER_TERM = 'groupFilterTerm'
+  GROUP_SEARCH_FOR = 'groupSearchFor'
+  TEST_RUNNER_FILTER_TERM = 'testRunnerFilterTerm'
+  TEST_RUNNER_SEARCH_FOR = 'testRunnerSearchFor'
+end

data/lib/helpers/printer.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+class Printer
+  # Prints a message in green to the console.
+  #
+  # Parameters:
+  # - message: A string message to be printed.
+  #
+  # Returns:
+  # None
+  def self.pass(message)
+    puts "\x1B[32m#{message}\x1B[0m"
+  end
+
+  # Prints a neutral message in red.
+  #
+  # Params:
+  # - message: The error message to be displayed.
+  #
+  # Returns:
+  # None
+  def self.fail(message)
+    puts "\x1B[31m#{message}\x1B[0m"
+  end
+
+  # Prints a neutral message in gray.
+  #
+  # Parameters:
+  # - message: A string representing the message to be printed.
+  #
+  # Returns: None
+  def self.neutral(message)
+    puts "\x1B[90m#{message}\x1B[0m"
+  end
+
+  # Generates a summary message based on the total number of tests, the number of successful tests,
+  # the number of failed tests, and the number of neutral tests. The summary message is formatted
+  # as a box with the following structure:
+  #
+  # - Summary: -------------------
+  # |                            |
+  # |  $total tests ran.              |
+  # |  - $successes passed.               |
+  # |  - $failures failed.               |
+  # |  - $neutrals skipped/inconclusive. |
+  # -------------------------------
+  #
+  # Parameters:
+  # - total (int): The total number of tests.
+  # - successes (int): The number of successful tests.
+  # - failures (int): The number of failed tests.
+  # - neutrals (int): The number of neutral tests.
+  #
+  # Returns:
+  # - message (str): The formatted summary message.
+  def self.summary(total, successes, failures, neutrals)
+    total_char_count = total.to_s.length
+    success_char_count = successes.to_s.length
+    failure_char_count = failures.to_s.length
+    neutral_char_count = neutrals.to_s.length
+    max_char_count = [total_char_count, success_char_count, failure_char_count, neutral_char_count].max
+
+    base_top_dash_spacer = 18
+    base_blank_spacer = 28
+    base_total_spacer = 14
+    base_success_spacer = 15
+    base_failure_spacer = 15
+    base_neutral_spacer = 1
+    box_length = 29
+
+    total_extra_space = max_char_count - total_char_count + base_total_spacer
+    success_extra_space = max_char_count - success_char_count + base_success_spacer
+    failure_extra_space = max_char_count - failure_char_count + base_failure_spacer
+    neutral_extra_space = max_char_count - neutral_char_count + base_neutral_spacer
+
+    # There are only two fields that might realistically overflow the box
+    # - total and neutrals. Since total will always be >= passed and failed
+    # count, we can just look at total and push out the space from there.
+    all_extra_space = 0
+
+    if neutral_extra_space == max_char_count && max_char_count > base_neutral_spacer
+      all_extra_space = max_char_count - base_neutral_spacer
+    elsif total_extra_space == max_char_count && max_char_count > base_total_spacer
+      all_extra_space = max_char_count - base_total_spacer
+    end
+
+    # Create a box that looks like this:
+    # - Summary: -------------------
+    # |                            |
+    # |  $total tests ran.              |
+    # |  - $successes passed.               |
+    # |  - $failures failed.               |
+    # |  - $neutrals skipped/inconclusive. |
+    # -------------------------------
+
+    message = "\n"
+    message += ' - Summary: '
+    (base_top_dash_spacer + all_extra_space).times do
+      message += '-'
+    end
+    message += "\n"
+
+    # |                            | (blank spacer line)
+    message += '|'
+    (base_blank_spacer + all_extra_space).times do
+      message += ' '
+    end
+    message += "|\n"
+
+    # |  $total tests ran.              |
+    message += "|  #{total} tests ran."
+    (total_extra_space + all_extra_space).times do
+      message += ' '
+    end
+    message += "|\n"
+
+    # |  - $successes passed.               |
+    message += "|  - #{successes} passed."
+    (success_extra_space + all_extra_space).times do
+      message += ' '
+    end
+    message += "|\n"
+
+    # |  - $failures failed.               |
+    message += "|  - #{failures} failed."
+    (failure_extra_space + all_extra_space).times do
+      message += ' '
+    end
+    message += "|\n"
+
+    # |  - $neutrals skipped/inconclusive. |
+    message += "|  - #{neutrals} skipped/inconclusive."
+    (neutral_extra_space + all_extra_space).times do
+      message += ' '
+    end
+    message += "|\n"
+
+    # -------------------------------
+    (box_length + all_extra_space).times do
+      message += '-'
+    end
+    message += "\n"
+
+    message
+  end
+end

data/lib/test_failure.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'test_result'
+require_relative 'helpers/printer'
+
+# Test that has failed, either with a provided message or thrown error
+class TestFailure < TestResult
+  def initialize(title, message = nil, err = nil)
+    super(title)
+    @message = message
+    @err = err
+  end
+
+  def report(spacer_count = 0)
+    super
+    Printer.fail(@spacer + format_message)
+    return if @err.nil?
+
+    # Extra space is to compensate for the [X]
+    Printer.fail("#{@spacer}    #{@err}")
+
+    # Mimic the default Ruby trace. This does not need additional formatting as
+    # some terminals recognize this as a stack trace.
+    puts @err.backtrace.join("\n\t")
+             .sub("\n\t", ": #{@err}#{@err.class ? " (#{@err.class})" : ''}\n\t")
+  end
+
+  def failures
+    1
+  end
+
+  private
+
+  def format_message
+    if @title.nil?
+      "    #{@message}"
+    else
+      "[X] #{@title}: #{@message}"
+    end
+  end
+end
+
+# Assert that has failed with a message explaining why the assertion failed
+class AssertFailure < AssertResult
+  def initialize(message)
+    super(message, nil)
+  end
+
+  def report(spacer_count)
+    super
+
+    Printer.fail(@spacer + format_message)
+  end
+end

data/lib/test_message.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'test_result'
+require_relative 'helpers/printer'
+
+# Prints system messages, generally ran by the CLI runner
+class TestMessage < TestResult
+  attr_accessor :message
+
+  def initialize(title, message)
+    super(title)
+    @message = message
+  end
+
+  def report(spacer_count = 0)
+    super
+    if message.nil?
+      Printer.neutral(@spacer + @title)
+    else
+      Printer.neutral("#{@spacer}#{@title} #{@message}")
+    end
+  end
+end