cake-tester 0.2.0

data/bin/collector.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../lib/helpers/printer'
+
+# Collector holds totals for all collectors and prints a summary
+class Collector
+  # @return [Integer]
+  attr_reader :total, :end_index
+
+  def initialize
+    @collectors = []
+    @total = 0
+    @successes = 0
+    @failures = 0
+    @neutrals = 0
+    @end_index = 0
+  end
+
+  # Adds a collector and updates the total, successes, failures, and neutrals
+  # @param collector [TestRunnerCollector]
+  def add_collector(collector)
+    @collectors << collector
+    @total += collector.total
+    @successes += collector.successes
+    @failures += collector.failures
+    @neutrals += collector.neutrals
+    @end_index = collector.end_index
+  end
+
+  def print_message(verbose)
+    summary = Printer.summary(@total, @successes, @failures, @neutrals)
+
+    if @failures.positive?
+      Printer.fail(summary)
+      @collectors.each(&:print_errors)
+    elsif @successes.zero?
+      Printer.neutral(summary)
+    else
+      Printer.pass(summary)
+    end
+
+    return unless verbose
+
+    @collectors.each(&:print_message)
+  end
+end
+
+# TestRunnerCollector holds totals for a single test runner
+class Test_Runner_Controller
+  # @return [Integer]
+  attr_reader :total
+  # @return [Integer]
+  attr_reader :successes
+  # @return [Integer]
+  attr_reader :failures
+  # @return [Integer]
+  attr_reader :neutrals
+  # @return [Integer]
+  attr_reader :end_index
+
+  # Initializes a new instance of the class.
+  #
+  # @param output [Array<String>] Total output of the TestRunner
+  # @param total [Integer] Total amount of tests from the TestRunner
+  # @param successes [Integer] Total amount of successes from the TestRunner
+  # @param failures [Integer] Total amount of failures from the TestRunner
+  # @param neutrals [Integer] Total amount of neutrals from the TestRunner
+  # @param end_index [Integer] Last line given by the TestRunner
+  def initialize(output, total:, successes:, failures:, neutrals:, end_index:)
+    @output = output
+    @total = total
+    @successes = successes
+    @failures = failures
+    @neutrals = neutrals
+    @end_index = end_index
+  end
+
+  def print_message
+    # This already has formatting from the printer, just pass through the original message
+    @output.each do |message|
+      puts message
+    end
+  end
+
+  def print_errors
+    return unless @failures.positive?
+
+    print_message
+  end
+end

data/bin/runner.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative 'collector'
+
+# Controls IO and output
+class Runner
+  # Retrieves all files with a cake.rb extension in the current directory
+  # @return [Array<String>]
+  def cake_file_list
+    # Get all files in the current directory, including subdirectories
+    Dir.glob('**/*.cake.rb')
+  end
+
+  # Runs the tests
+  # @param settings [Settings]
+  # @param cake_list [Array<String>]
+  def run(settings, cake_list)
+    collector = Collector.new
+    process_args = settings.test_filter.to_properties
+
+    cake_list.each do |file|
+      next if settings.file_filter && !file.include?(settings.file_filter)
+
+      r, w = IO.pipe
+      pid = Process.spawn('ruby', file, process_args.join(' '), out: w, err: %i[child out])
+      w.close
+      pid, status = Process.wait2
+      output = r.read
+      r.close
+
+      collectors = test_runner_output_parser(output)
+      collectors.each do |c|
+        collector.add_collector(c)
+      end
+
+      puts "#{collector.total} tests found in #{file}..." if settings.verbose
+    end
+
+    collector.print_message(settings.verbose || settings.vs_code)
+    return if settings.vs_code
+
+    # This makes sure to clear out any color changes
+    Printer.neutral('')
+  end
+
+  def show_help
+    puts 'Usage: cake-tester [options]'
+    puts '  -h, --help            Show this help message'
+    puts '  -i, --interactive     Interactive mode'
+    puts '  -v, --verbose         Verbose output'
+    puts ''
+    puts 'Test Filters: '
+    puts <<~HELP
+      -t    General search:         -t "foo"                  Run all tests, groups, and runners with "foo" in the title
+      --tt  Test search:            --tt "cool test"          Run all tests with the phrase "cool test" in the title
+      --tte Test search, exact:     --tte "should pass when true"      Runs only the test that matches the phrase exactly.
+      --tg  Group search:           --tg "bar"                Run all groups matching "bar" in the title
+      --tge Group search, exact:    --tge "API Endpoints"     Runs all groups exactly matching the phrase "API Endpoints"
+      --tr  Test Runner search:     --tr "Models"             Runs all test runners with "Models" in the title
+      --tre Test Runner search, exact: --tre "Models - User"       Runs test runners that exactly match the phrase "Models - User"
+    HELP
+  end
+
+  private
+
+  # Parses output from the process
+  # @param output [String]
+  # @return [Array<TestRunnerCollector>]
+  def test_runner_output_parser(output)
+    test_runner_collectors = []
+    lines = output.lines
+    cursor = 0
+
+    while cursor < (lines.length - 1)
+      line = lines[cursor]
+      test_runner_collector = test_runner_output_parse(lines, cursor)
+      cursor = test_runner_collector.end_index
+      test_runner_collectors << test_runner_collector
+    end
+
+    test_runner_collectors
+  end
+
+  # @param lines [Array<String>] All output lines
+  # @param cursor [Integer] Current index of the cursor in the output
+  # @return [TestRunnerCollector]
+  def test_runner_output_parse(lines, cursor)
+    test_output = []
+    total = 0
+    successes = 0
+    failures = 0
+    neutrals = 0
+    at_summary_line = -1
+    summary_line = ' - Summary: ---------------'
+    total_line = /(\d*) tests ran\./
+    success_line = /(\d*) passed\./
+    failed_line = /(\d*) failed\./
+    neutral_line = %r{(\d*) skipped/inconclusive\.}
+    i = cursor
+    while i < lines.length - 1 || at_summary_line == 7
+      line = lines[i]
+      at_summary_line = 0 if line.include? summary_line
+
+      case at_summary_line
+      when 2
+        total = total_line.match(line)[1].to_i
+      when 3
+        successes = success_line.match(line)[1].to_i
+      when 4
+        failures = failed_line.match(line)[1].to_i
+      when 5
+        neutrals = neutral_line.match(line)[1].to_i
+      end
+
+      if at_summary_line > -1
+        at_summary_line += 1
+      else
+        test_output << line
+      end
+
+      i += 1
+    end
+
+    Test_Runner_Controller.new(
+      test_output,
+      total: total,
+      successes: successes,
+      failures: failures,
+      neutrals: neutrals,
+      end_index: i
+    )
+  end
+end

data/bin/settings.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../lib/helpers/filter_settings'
+
+# Converts args into easily accessible settings
+class Settings
+  attr_reader :verbose, :file_filter, :vs_code, :interactive, :test_filter, :show_help
+
+  def initialize
+    @verbose = ARGV.include?('-v') || ARGV.include?('--verbose')
+    @file_filter = get_from_args('-f')
+    @vs_code = ARGV.include? '--vs-code'
+    @interactive = ARGV.include?('-i') || ARGV.include?('--interactive')
+    @show_help = ARGV.include?('-h') || ARGV.include?('--help')
+    @test_filter = FilterSettings.new(
+      general_search_term: get_from_args('-t'),
+      test_filter_term: get_from_args('--tt'),
+      test_search_for: get_from_args('--tte'),
+      group_filter_term: get_from_args('--tg'),
+      group_search_for: get_from_args('--tge'),
+      test_runner_filter_term: get_from_args('--tr'),
+      test_runner_search_for: get_from_args('--tre')
+    )
+  end
+
+  private
+
+  # @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

data/cake-tester.gemspec

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |gem|
+  gem.name          = 'cake-tester'
+  gem.version       = '0.2.0'
+  gem.authors       = ['Polyhedra', 'C. Lee Spruit']
+  gem.summary       = 'The lightweight, explicit testing framework for Ruby.'
+  gem.description   = ''
+  gem.homepage      = 'https://github.com/Polyhedra-Studio/Cake-Ruby'
+  gem.license       = 'MPL-2.0'
+  gem.required_ruby_version = '>= 2.7.0'
+  gem.metadata['rubygems_mfa_required'] = 'true'
+
+  gem.files = `git ls-files -z`.split("\x0")
+  # gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.executables << 'cake'
+  gem.require_paths = ['lib']
+end

data/lib/cake.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'expect'
+require_relative 'contextual/group'
+require_relative 'contextual/test_runner'
+require_relative 'contextual/test'

data/lib/contextual/child.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../test_options'
+
+# Contextual is a wrapper for Node and Node attributes
+module Contextual
+  # A Child is a Node that has a parent
+  module Child
+    # Handles assigning parent information to child
+    #
+    # @param parent_options [TestOptions] Options from parent to copy to child
+    def assign_parent(parent_options)
+      @parent_count = 0 if @parent_count.nil?
+      @parent_count += 1
+
+      @options = TestOptions.new if @options.nil?
+      @options.map_from_parent(parent_options)
+    end
+  end
+end

data/lib/contextual/context.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+# The Context is used to pass information between different stages of a Test.
+# Context is inherited from parent to child, but not sibling to sibling.
+# The Context object is an OpenStruct, which means you can dynamically assign
+# as needed.
+class Context < OpenStruct
+  # @return [Object] actual expected object, ideally will be set during the
+  #   Contexual::Node#run_action step
+  attr_accessor :actual
+
+  # @return [Object] expected
+  attr_accessor :expected
+
+  def initialize
+    super
+    @expected = nil
+    @actual = nil
+  end
+
+  # @param [Context] parent_context
+  def apply(parent_context)
+    @expected = parent_context.expected
+    @actual = parent_context.actual
+
+    parent_context.each_pair do |key, value|
+      self[key] = value
+    end
+  end
+end

data/lib/contextual/group.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'child'
+require_relative 'node'
+require_relative 'parent'
+
+# A Group is a organizational class that holds other tests. You can nest as many
+# groups as you like.
+class Group < Contextual::Node
+  include Contextual::Child
+  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)
+  end
+
+  # Should this run with the current filter settings
+  # @param filter_settings [FilterSettings]
+  # @return [Boolean]
+  def should_run_with_filter(filter_settings)
+    # This should run failrly close to testRunner's version
+    return @title == filter_settings.group_search_for if filter_settings.has_group_search_for
+    return @title.include? filter_settings.group_filter_term if filter_settings.has_group_filter_term
+
+    should_run_with_search_term_with_children(filter_settings)
+  end
+
+  # Report results, if any
+  # @param filter_settings [FilterSettings]
+  # @return [TestResult, Nil]
+  def report(filter_settings)
+    @result.report(@parent_count)
+    return if @skip
+
+    report_children(filter_settings)
+  end
+end

data/lib/contextual/node.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative '../test_options'
+
+module Contextual
+  # @abstract Base class for testing nodes, like TestRunner, Group, and Test.
+  class Node
+    attr_reader :skip, :result
+
+    def initialize(title, setup: nil, teardown: nil, options: nil, skip: false)
+      @title = title
+      @setup = setup
+      @teardown = teardown
+      @options = options.nil? ? TestOptions.new : options
+      @skip = skip
+      @context = Context.new
+    end
+
+    # @param current_context [Context] Parent or root context
+    # @param filter_settings [FilterSettings]
+    # @return [TestResult]
+    def run(current_context, filter_settings)
+      if @skip
+        @result = TestNeutral.new(@title, 'Skipped')
+      else
+        @context.apply(current_context)
+        @result = get_result(filter_settings)
+      end
+      @result
+    end
+
+    # Runs the setup hook
+    # @return [TestResult, Nil] Returns a TestFailure if the setup fails
+    def run_setup
+      return if @setup.nil?
+
+      begin
+        @setup.call(@context)
+        nil
+      rescue StandardError => e
+        @result = TestFailure.new(@title, 'Failed during setup', e)
+      end
+    end
+
+    # Runs the teardown hook
+    # @return [TestResult, Nil] Returns a TestFailure if the teardown fails
+    def run_teardown
+      return if @teardown.nil?
+
+      begin
+        @teardown.call(@context)
+        nil
+      rescue StandardError => e
+        if @result.successes.positive?
+          TestFailure.new(@title, 'Tests passed, but failed during teardown.', e)
+        else
+          TestFailure.new(@title, 'Failed during teardown', e)
+        end
+      end
+    end
+
+    # @abstract Override this method in your subclass
+    # @param _filter_settings [FilterSettings] not used
+    # @return [TestResult]
+    def get_result(_filter_settings)
+      # This has been marked as skipped - do nothing
+      TestNeutral.new(@title, 'Skipped') if @skip
+    end
+
+    # Should this run with the current filter settings, checking general search
+    # @param filter_settings [FilterSettings]
+    # @return [Boolean]
+    def should_run_with_search_term(filter_settings)
+      # Check if the general search term applies here
+      return @title.include?(filter_settings.general_search_term) if filter_settings.has_general_search_term
+
+      true
+    end
+  end
+end

data/lib/contextual/parent.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative '../test_failure'
+require_relative '../test_neutral'
+require_relative '../test_pass'
+
+module Contextual
+  # A Parent is a Node that can have children
+  module Parent
+    # @return [Array<Node>]
+    attr_reader :children
+
+    # @param children [Array<Node>]
+    def set_parent(children = [])
+      @children = children
+      @test_fail_count = 0
+      @test_success_count = 0
+      @test_neutral_count = 0
+      @filter_applies_to_children = false
+      assign_children
+    end
+
+    # @param parent_options [TestOptions]
+    # @return [void]
+    def assign_parent(parent_options)
+      super
+      @children.each do |child|
+        next unless child.respond_to?(:assign_parent)
+
+        child.assign_parent(parent_options)
+      end
+    end
+
+    # @param filter_settings [FilterSettings]
+    # @return [Boolean]
+    def should_run_with_search_term_with_children(filter_settings)
+      # Check if the general search term applies here
+      return true if should_run_with_search_term(filter_settings)
+
+      if filter_settings.has_test_filter_term ||
+         filter_settings.has_test_search_for
+        should_run_filter_on_children(filter_settings)
+      end
+
+      # No applicable filter
+      true
+    end
+
+    # @param filter_settings [FilterSettings]
+    # @return [void]
+    def report_children(filter_settings)
+      @children.each do |child|
+        if @filter_applies_to_children
+          child.report(filter_settings) if child.should_run_with_filter(filter_settings)
+        else
+          child.report(filter_settings)
+        end
+      end
+    end
+
+    # @param filter_settings [FilterSettings]
+    # @return [TestResult]
+    def get_result(filter_settings)
+      super
+
+      # This is just a stub if there's no children - do nothing
+      return TestNeutral.new(@title, 'Empty - no tests') if @children.empty?
+
+      @result = run_setup
+
+      return @result unless @result.nil?
+
+      @result = get_result_children(filter_settings)
+
+      teardown_failure = run_teardown
+      @result = teardown_failure unless teardown_failure.nil?
+
+      @result
+    end
+
+    # Counts all successes, including children
+    # @return [Integer]
+    def successes
+      current_success_count = @test_success_count
+      @children.each do |child|
+        current_success_count += child.successes if child.instance_of? Group
+      end
+      current_success_count
+    end
+
+    # Counts all failures, including children
+    # @return [Integer]
+    def failures
+      current_fail_count = @test_fail_count
+      @children.each do |child|
+        current_fail_count += child.failures if child.instance_of? Group
+      end
+      current_fail_count
+    end
+
+    # Counts all neutrals, including children
+    # @return [Integer]
+    def neutrals
+      current_neutral_count = @test_neutral_count
+      @children.each do |child|
+        current_neutral_count += child.neutrals if child.instance_of? Group
+      end
+      current_neutral_count
+    end
+
+    # Counts all tests, including children
+    # @return [Integer]
+    def total
+      test_count = 0
+      @children.each do |child|
+        if child.instance_of? Group
+          test_count += child.total
+        elsif child.instance_of?(Test) && child.ran_successfully
+          test_count += 1
+        end
+      end
+      test_count
+    end
+
+    # Handles when there is a error that makes it impossible to run
+    # @return [TestFailure]
+    def critical_inconclusive
+      super
+      @children.each do |child|
+        child.critical_inconclusive
+        @test_neutral_count += 1
+      end
+    end
+
+    private
+
+    # Notifies the children that they have a parent
+    # @return [void]
+    def assign_children
+      @children.each do |child|
+        if child.respond_to?(:assign_parent)
+          child.assign_parent(@options)
+        else
+          # Someone tried to add something that isn't a child into their test suite
+          throw 'Only objects like Group or Test can be children of another node.'
+        end
+      end
+    end
+
+    # @param filter_settings [FilterSettings]
+    # @return [Boolean]
+    def should_run_filter_on_children(filter_settings)
+      @filter_applies_to_children = true
+      @children.any? { |child| child.should_run_with_filter(filter_settings) }
+    end
+
+    # @param filter_settings [FilterSettings]
+    # @return [TestResult]
+    def get_result_children(filter_settings)
+      child_success_count = 0
+      child_fail_count = 0
+      @children.each do |child|
+        result = get_result_child(filter_settings, child)
+        next if result.nil?
+
+        child_success_count += result.successes
+        child_fail_count += result.failures
+
+        next unless child.instance_of? Test
+
+        @test_success_count += result.successes
+        @test_fail_count += result.failures
+        @test_neutral_count += result.neutrals
+      end
+
+      return TestFailure.new(@title, 'Some tests failed') if child_fail_count.positive?
+      return TestNeutral.new(@title) if child_success_count.zero?
+
+      TestPass.new(@title)
+    end
+
+    # @param filter_settings [FilterSettings]
+    # @param child [Node]
+    # @return [TestResult, nil]
+    def get_result_child(filter_settings, child)
+      return if @filter_applies_to_children && !child.should_run_with_filter(filter_settings)
+
+      child.run(@context.dup, filter_settings)
+    end
+  end
+end