simmer 2.0.0.pre.alpha.1 → 4.0.0

data/lib/simmer/configuration/callback_dsl.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Simmer
+  class Configuration
+    # Defines lifecycle hooks which can be run before and after the entire
+    # suite or just a single test. Very similar to Rspec
+    # (https://relishapp.com/rspec/rspec-core/v/3-9/docs/hooks/before-and-after-hooks).
+    class CallbackDsl
+      def initialize
+        @before_suite = []
+        @after_suite = []
+        @before_each = []
+        @after_each = []
+
+        freeze
+      end
+
+      # Used to create a before callback. This accepts and optional level
+      # parameter which can either be :suite or :each. ":each" is implied if no
+      # level is provided.
+      def before(level = LEVEL_EACH, &block)
+        verify_level!(level)
+
+        level == LEVEL_SUITE ? before_suite.push(block) : before_each.push(block)
+      end
+
+      # Used to create an after callback. This accepts and optional level
+      # parameter which can either be :suite or :each. ":each" is implied if no
+      # level is provided.
+      def after(level = LEVEL_EACH, &block)
+        verify_level!(level)
+
+        level == LEVEL_SUITE ? after_suite.push(block) : after_each.push(block)
+      end
+
+      # :nodoc:
+      def run_single_test_with_callbacks
+        before_each.each(&:call)
+
+        result = yield
+
+        after_each.each { |block| block.call(result) }
+
+        result
+      end
+
+      # :nodoc:
+      def run_suite_with_callbacks
+        before_suite.each(&:call)
+
+        result = yield
+
+        after_suite.each { |block| block.call(result) }
+
+        result
+      end
+
+      private
+
+      def verify_level!(level)
+        raise ArgumentError, "unknown test level: #{level}" unless CALLBACK_LEVELS.include?(level)
+      end
+
+      attr_reader :after_each, :before_each, :after_suite, :before_suite
+
+      LEVEL_EACH = :each
+      LEVEL_SUITE = :suite
+      CALLBACK_LEVELS = Set.new([LEVEL_EACH, LEVEL_SUITE])
+      private_constant :LEVEL_EACH, :LEVEL_SUITE, :CALLBACK_LEVELS
+    end
+  end
+end

data/lib/simmer/database/fixture_set.rb

@@ -13,6 +13,8 @@ module Simmer
   module Database
     # Hydrate a collection of Fixture instances from configuration.
     class FixtureSet
+      class FixtureMissingError < StandardError; end
+
       def initialize(config = {})
         @fixtures_by_name = config_to_fixures_by_name(config)
 
@@ -22,7 +24,7 @@ module Simmer
       def get!(name)
         key = name.to_s
 
-        raise ArgumentError, "fixture not found: #{name}" unless fixtures_by_name.key?(key)
+        raise FixtureMissingError, "fixture missing: #{name}" unless fixtures_by_name.key?(key)
 
         fixtures_by_name[key]
       end

data/lib/simmer/externals/mysql_database.rb

@@ -27,7 +27,7 @@ module Simmer
       end
 
       def records(table, columns = [])
-        query = "SELECT #{sql_select_params(columns)} FROM #{table}"
+        query = "SELECT #{sql_select_params(columns)} FROM #{qualify(table)}"
 
         client.query(query).to_a
       end
@@ -53,7 +53,11 @@ module Simmer
       attr_reader :client, :fixture_set, :table_names
 
       def sql_select_params(columns)
-        Array(columns).any? ? Array(columns).map { |c| client.escape(c) }.join(',') : '*'
+        if Array(columns).any?
+          Array(columns).map { |c| qualify(client.escape(c)).to_s }.join(',')
+        else
+          '*'
+        end
       end
 
       def seed_sql_statements(fixtures)
@@ -62,7 +66,7 @@ module Simmer
 
       def clean_sql_statements
         table_names.map do |table_name|
-          "TRUNCATE #{table_name}"
+          "TRUNCATE #{qualify(table_name)}"
         end
       end
 
@@ -110,6 +114,10 @@ module Simmer
 
         raise ArgumentError, "database (#{name}) must end in #{DATABASE_SUFFIX}"
       end
+
+      def qualify(identifier)
+        "`#{identifier}`"
+      end
     end
   end
 end

data/lib/simmer/externals/spoon_client.rb

@@ -24,13 +24,13 @@ module Simmer
         freeze
       end
 
-      def run(specification, config)
+      def run(specification, config, &output_capturer)
         execution_result = nil
         time_in_seconds  = nil
 
         begin
           time_in_seconds = Benchmark.measure do
-            execution_result = execute!(specification, config)
+            execution_result = execute!(specification, config, &output_capturer)
           end.real
         rescue Pdi::Spoon::PanError, Pdi::Spoon::KitchenError => e
           return Result.new(
@@ -50,14 +50,15 @@ module Simmer
 
       attr_reader :files_dir
 
-      def execute!(specification, config)
+      def execute!(specification, config, &output_capturer)
         act = specification.act
 
         spoon.run(
           repository: act.repository,
           name: act.name,
           params: act.compiled_params(files_dir, config),
-          type: act.type
+          type: act.type,
+          &output_capturer
         )
       end
     end

data/lib/simmer/judge/result.rb

@@ -13,7 +13,7 @@ module Simmer
     class Result
       attr_reader :bad_assertions
 
-      def initialize(bad_assertions)
+      def initialize(bad_assertions = [])
         @bad_assertions = bad_assertions
 
         freeze

data/lib/simmer/re_runner.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'judge'
+require_relative 'runner/result'
+
+module Simmer
+  # :nodoc:
+  # Wraps a <tt>Simmer::Runner</tt> and knows how to re-run tests based
+  # on certain failure cases.
+  class ReRunner < SimpleDelegator
+    attr_reader :timeout_failure_retry_count
+
+    def initialize(runner, out, timeout_failure_retry_count: 0)
+      @timeout_failure_retry_count = timeout_failure_retry_count.to_i
+      @out = out
+
+      super(runner)
+    end
+
+    def run(*args)
+      rerun_on_timeout(args, timeout_failure_retry_count)
+    end
+
+    private
+
+    attr_reader :out
+
+    def rerun_on_timeout(run_args, times)
+      result = __getobj__.run(*run_args)
+
+      if result.timed_out? && times.positive?
+        out.console_puts('Retrying due to a timeout...')
+        rerun_on_timeout(run_args, times - 1)
+      else
+        result
+      end
+    end
+  end
+end

data/lib/simmer/runner.rb

@@ -9,6 +9,7 @@
 
 require_relative 'judge'
 require_relative 'runner/result'
+require_relative 'runner/timeout_error'
 
 module Simmer
   # Runs a single specification.
@@ -26,110 +27,109 @@ module Simmer
       freeze
     end
 
-    def run(specification, config: {}, id: SecureRandom.uuid)
-      print("Name: #{specification.name}")
-      print("Path: #{specification.path}")
+    def run(specification, config:, id: SecureRandom.uuid)
+      out.announce_start(id, specification)
 
-      clean_db
-      seed_db(specification)
-      clean_file_system
-      seed_file_system(specification)
+      config.run_single_test_with_callbacks do
+        clean_and_seed(specification)
 
-      spoon_client_result = execute_spoon(specification, config)
-      judge_result        = assert(specification, spoon_client_result)
+        spoon_client_result = execute_spoon(specification, config)
+        judge_result        = assert(specification, spoon_client_result)
 
-      Result.new(id, judge_result, specification, spoon_client_result).tap do |result|
-        msg = pass_message(result)
-        print_waiting('Done', 'Final verdict')
-        print(msg)
+        Result.new(
+          id: id,
+          judge_result: judge_result,
+          specification: specification,
+          spoon_client_result: spoon_client_result
+        ).tap { |result| out.final_verdict(result) }
+      rescue Database::FixtureSet::FixtureMissingError, Simmer::Runner::TimeoutError => e
+        Result.new(id: id, specification: specification, errors: e)
+              .tap { |result| out.final_verdict(result) }
       end
     end
 
+    def complete
+      out.close
+    end
+
     private
 
     attr_reader :database, :file_system, :fixture_set, :judge, :out
 
+    def clean_and_seed(specification)
+      clean_db
+      seed_db(specification)
+      clean_file_system
+      seed_file_system(specification)
+    end
+
     def clean_db
-      print_waiting('Stage', 'Cleaning database')
+      out.waiting('Stage', 'Cleaning database')
       count = database.clean!
-      print("#{count} table(s) emptied")
+      out.console_puts("#{count} table(s) emptied")
 
       count
     end
 
     def seed_db(specification)
-      print_waiting('Stage', 'Seeding database')
+      out.waiting('Stage', 'Seeding database')
 
       fixtures = specification.stage.fixtures.map { |f| fixture_set.get!(f) }
       count    = database.seed!(fixtures)
 
-      print("#{count} record(s) inserted")
+      out.console_puts("#{count} record(s) inserted")
 
       count
+    rescue Database::FixtureSet::FixtureMissingError => e
+      out.console_puts('Missing Fixture(s)')
+      raise e
     end
 
     def clean_file_system
-      print_waiting('Stage', 'Cleaning File System')
+      out.waiting('Stage', 'Cleaning File System')
       count = file_system.clean!
-      print("#{count} file(s) deleted")
+      out.console_puts("#{count} file(s) deleted")
 
       count
     end
 
     def seed_file_system(specification)
-      print_waiting('Stage', 'Seeding File System')
+      out.waiting('Stage', 'Seeding File System')
       count = file_system.write!(specification.stage.files)
-      print("#{count} file(s) uploaded")
+      out.console_puts("#{count} file(s) uploaded")
 
       count
     end
 
     def execute_spoon(specification, config)
-      print_waiting('Act', 'Executing Spoon')
-      spoon_client_result = spoon_client.run(specification, config)
-      msg = pass_message(spoon_client_result)
-      print(msg)
+      out.waiting('Act', 'Executing Spoon')
+
+      spoon_client_result = spoon_client.run(specification, config.config) do |output|
+        out.capture_spoon_output(output)
+      end
+
+      out.finish_spec
+      out.spoon_execution_detail_message(spoon_client_result)
 
       spoon_client_result
+    rescue Timeout::Error => e
+      out.console_puts('Timed out')
+      raise Simmer::Runner::TimeoutError, e
     end
 
     def assert(specification, spoon_client_result)
-      print_waiting('Assert', 'Checking results')
+      out.waiting('Assert', 'Checking results')
 
       if spoon_client_result.fail?
-        print('Skipped')
+        out.console_puts('Skipped')
         return nil
       end
 
       output       = spoon_client_result.execution_result.out
       judge_result = judge.assert(specification, output)
-      msg          = pass_message(judge_result)
-
-      print(msg)
+      out.result(judge_result)
 
       judge_result
     end
-
-    def print(msg)
-      out.puts(msg)
-    end
-
-    def print_waiting(stage, msg)
-      max  = 25
-      char = '.'
-      msg  = "  > #{pad_right(stage, 6)} - #{pad_right(msg, max, char)}"
-
-      out.print(msg)
-    end
-
-    def pad_right(msg, len, char = ' ')
-      missing = len - msg.length
-
-      "#{msg}#{char * missing}"
-    end
-
-    def pass_message(obj)
-      obj.pass? ? 'Pass' : 'Fail'
-    end
   end
 end

data/lib/simmer/runner/result.rb

@@ -13,29 +13,47 @@ module Simmer
     class Result
       extend Forwardable
 
-      attr_reader :id, :judge_result, :specification, :spoon_client_result
-
-      def_delegators :spoon_client_result, :time_in_seconds
+      attr_reader :errors, :id, :judge_result, :specification, :spoon_client_result
 
       def_delegators :specification, :name
 
-      def initialize(id, judge_result, specification, spoon_client_result)
+      def initialize(
+        id:,
+        specification:,
+        judge_result: nil,
+        spoon_client_result: nil,
+        errors: []
+      )
         @id                  = id.to_s
         @judge_result        = judge_result
         @specification       = specification
         @spoon_client_result = spoon_client_result
+        @errors              = Array(errors)
 
         freeze
       end
 
+      def time_in_seconds
+        spoon_client_result&.time_in_seconds || 0
+      end
+
       def pass?
-        judge_result&.pass? && spoon_client_result&.pass?
+        [
+          judge_result&.pass?,
+          spoon_client_result&.pass?,
+          errors.empty?,
+        ].all?
       end
+      alias passing? pass?
 
       def fail?
         !pass?
       end
 
+      def timed_out?
+        errors.any? { |e| e.is_a?(Simmer::Runner::TimeoutError) }
+      end
+
       def to_h
         {
           'name' => specification.name,
@@ -44,7 +62,8 @@ module Simmer
           'time_in_seconds' => time_in_seconds,
           'pass' => pass?,
           'spoon_client_result' => spoon_client_result.to_h,
-          'judge_result' => judge_result.to_h
+          'judge_result' => judge_result.to_h,
+          'errors' => errors.map(&:message),
         }
       end
     end