thoreau 0.2.1 → 0.2.2

data/lib/thoreau/errors.rb

@@ -0,0 +1,15 @@
+module Thoreau
+  class TestCasesAtMultipleLevelsError < RuntimeError
+    def initialize(msg = nil)
+      super "Test cases must be specified either at the top level or inside test_cases blocks, but not both!"
+    end
+  end
+
+  class OverriddenActionError < RuntimeError
+    def initialize(msg = nil)
+      super "Extra action/subject provided for tests. Actions/subjects must be specified EITHER in the `suite` or within `test_cases` (not both)."
+    end
+  end
+
+
+end

data/lib/thoreau/legacy_expected_outcomes.rb

@@ -0,0 +1,53 @@
+require 'logger'
+require 'json'
+require "pstore"
+
+module Thoreau
+
+  class LegacyExpectedOutcomes
+
+    # A simple store of expected outcomes of test cases.
+    #
+    # They are stored in a "pstore" database, with the test descriptor
+    # and inputs being the key. If you change the input of the test, it
+    # should generate a new saved result.
+    #
+    # Set ENV['RESET_SNAPSHOTS'] to, well, reset all the snapshots.
+
+    VERSION = 1
+
+    def initialize(suite_name)
+      @suite_name = suite_name
+    end
+
+    def key_for(test_case)
+      o = {
+        desc:  test_case.family_desc,
+        input: test_case.input
+      }
+      o.to_json
+    end
+
+    def has_saved_for? test_case
+      logger.debug("has_saved_for? for #{key_for(test_case)}")
+      !!(load_for test_case)
+    end
+
+    def load_for test_case
+      logger.debug("load_for for #{key_for(test_case)}")
+      wiki = PStore.new(Thoreau.configuration.legacy_outcome_path)
+      wiki.transaction do
+        wiki[key_for(test_case)]
+      end
+    end
+
+    def save! test_case
+      logger.debug("save! for #{key_for(test_case)}")
+      wiki = PStore.new(Thoreau.configuration.legacy_outcome_path)
+      wiki.transaction do
+        wiki[key_for(test_case)] = test_case.actual
+      end
+    end
+
+  end
+end

data/lib/thoreau/logging.rb

@@ -0,0 +1,36 @@
+require 'logger'
+
+# https://stackoverflow.com/questions/917566/ruby-share-logger-instance-among-module-classes
+# The intended use is via "include":
+module Thoreau
+  module Logging
+    class << self
+      def logger
+        if @logger.nil?
+          @logger = Logger.new(STDOUT, formatter: proc { |severity, datetime, progname, msg|
+            "#{severity}: #{msg}\n"
+          })
+          @logger.level = Logger::INFO
+          @logger.level = Logger::DEBUG if ENV['DEBUG']
+        end
+        @logger
+      end
+
+      # def logger=(logger)
+      #   @logger = logger
+      # end
+    end
+
+    def self.included(base)
+      class << base
+        def logger
+          Logging.logger
+        end
+      end
+    end
+
+    def logger
+      Logging.logger
+    end
+  end
+end

data/lib/thoreau/models/appendix.rb

@@ -0,0 +1,17 @@
+module Thoreau
+  module Models
+    class Appendix
+
+      attr_reader :setups
+
+      def initialize setups: {}
+        @setups = setups
+      end
+
+      def add_setup setup
+        raise "Duplicate setup block #{setup.name}" unless setups[setup.name].nil?
+        @setups[setup.name] = setup
+      end
+    end
+  end
+end

data/lib/thoreau/models/outcome.rb

@@ -0,0 +1,33 @@
+module Thoreau
+  module Models
+    class Outcome
+      # Reprents the outcome of a given test case.
+      # It can either be successful and have an `output`,
+      # or it can raise an exception.
+      #
+      # This is used both for recording what happens to a test
+      # and for representing the expectations for what will happen.
+      # It is also used to save as a "snapshot" for legacy tests.
+
+      include Thoreau::Logging
+
+      attr_reader :output
+      attr_reader :exception
+
+      def initialize output: nil,
+                     exception: nil
+
+        if output.is_a?(Proc)
+          @output_proc = output
+        else
+          @output = output
+        end
+        @exception = exception
+      end
+
+      def evaluate(result, context)
+        @output = context.instance_exec(result, &(@output_proc)) if @output_proc
+      end
+    end
+  end
+end

data/lib/thoreau/models/setup.rb

@@ -0,0 +1,17 @@
+module Thoreau
+  module Models
+
+    class Setup
+
+      attr_reader :name, :values, :block
+
+      def initialize name, values, block
+        @name   = name.to_s
+        @values = values
+        # @value = [values].flatten unless values.nil?
+        @block = block
+      end
+
+    end
+  end
+end

data/lib/thoreau/models/test_case.rb

@@ -0,0 +1,110 @@
+require 'active_support/core_ext/module/delegation'
+require_relative '../case/context_builder'
+require_relative './outcome'
+require_relative '../legacy_expected_outcomes'
+
+module Thoreau
+  module Models
+    class TestCase
+
+      include Thoreau::Logging
+
+      attr_reader :actual, :family_desc, :input
+      attr_accessor :expectation
+
+      def initialize family_desc:,
+                     input:,
+                     action_block:,
+                     expectation:,
+                     asserts:,
+                     negativo:
+
+        @family_desc  = family_desc
+        @input        = input
+        @action_block = action_block
+        @negativo     = negativo
+
+        @expectation = expectation
+
+        @assert_proc = asserts
+
+        @ran = false
+      end
+
+      def failure_expected?
+        @negativo
+      end
+
+      def desc
+        "#{@family_desc} #{(@input == {} ? nil : @input.sort.to_h) || @expectation.exception || "(no args)"}"
+      end
+
+      def problem
+
+        run unless @ran
+
+        if @expectation.exception
+
+          logger.debug " -> Expected Exception #{@expectation.exception} @actual.exception:#{@actual.exception}"
+
+          if @actual.exception.to_s == @expectation.exception.to_s
+            nil
+          elsif @actual.exception.nil?
+            "Expected exception, but none raised"
+          elsif @actual.exception.is_a?(NameError)
+            "Did you forget to define an input? Error: #{@actual.exception}"
+          else
+            "Expected '#{@expectation.exception}' exception, but raised '#{@actual.exception}' (#{@actual.exception.class.name})"
+          end
+
+        elsif @assert_proc
+
+          logger.debug " -> Assert Proc result=#{@assert_result}"
+
+          @assert_result ? nil : "Assertion failed. (got #{@assert_result})"
+        else
+
+          logger.debug " -> Result expected: result=#{@actual.output} expected_output: #{@expectation.output} @actual.exception:#{@actual.exception}"
+
+          if @actual.exception
+            "Expected output, but raised exception '#{@actual.exception}'"
+          elsif @expectation.output != @actual.output
+            "Expected '#{@expectation.output}', but got '#{@actual.output}'"
+          else
+            nil
+          end
+        end
+      end
+
+      def ok?
+        failure_expected? ^ !!problem.nil?
+      end
+
+      def failed?
+        !ok?
+      end
+
+      def run
+        logger.debug "## RUN #{desc}"
+        context_builder = Case::ContextBuilder.new(input: @input)
+        context         = context_builder.create_context
+        begin
+          # Only capture exceptions around the action itself.
+          output  = context.instance_exec(&(@action_block))
+          @actual = Models::Outcome.new output: output
+        rescue Exception => e
+          logger.debug("** Exception: #{e.class.name} #{e}")
+          logger.debug("Available local variables: #{@input.keys.empty? ? '(none)' : @input.keys.to_sentence}") if e.is_a? NameError
+          @actual = Models::Outcome.new exception: e
+          return
+        ensure
+          @ran = true
+        end
+
+        @expectation.evaluate(@actual.output, context) unless @expectation == :use_legacy_snapshot
+        @assert_result = context.instance_exec(@actual.output, &(@assert_proc)) if @assert_proc
+      end
+
+    end
+  end
+end

data/lib/thoreau/models/test_clan.rb

@@ -0,0 +1,37 @@
+require 'active_support/core_ext/module/delegation'
+require_relative '../errors'
+
+module Thoreau
+
+  module Models
+    class TestClan # set of TestFamilies
+
+      include Thoreau::Logging
+
+      attr_accessor :test_families, :appendix
+      attr_reader :name, :action_block
+
+      delegate :empty?, to: :test_families
+
+      def initialize(name, appendix:, action_block: nil)
+        @name          = name
+        @test_families = []
+        @appendix      = appendix
+        @action_block  = action_block
+      end
+
+      def action_block= block
+        raise OverriddenActionError unless @action_block.nil?
+        @action_block = block
+      end
+
+      def add_test_family fam
+        logger.debug "   + Adding test family #{fam}"
+        fam.desc = self.name if fam.desc.blank?
+        @test_families.push fam
+        fam
+      end
+
+    end
+  end
+end

data/lib/thoreau/models/test_family.rb

@@ -0,0 +1,53 @@
+module Thoreau
+  module Models
+
+    class TestFamily
+      attr_reader :asserts,
+                  :expected_exception,
+                  :expected_output,
+                  :kind,
+                  :setups
+      attr_writer :focus
+      attr_accessor :use_legacy_snapshot
+      attr_accessor :desc
+
+      def initialize(asserts:,
+                     desc:,
+                     expected_exception:,
+                     expected_output:,
+                     failure_expected:,
+                     input_specs:,
+                     kind:,
+                     setups:
+      )
+        @asserts            = asserts
+        @desc               = desc
+        @expected_exception = expected_exception
+        @expected_output    = expected_output
+        @failure_expected   = failure_expected
+        @input_specs        = input_specs
+        @kind               = kind
+        @setups             = setups
+      end
+
+      def input_specs
+        @input_specs.size == 0 ?
+          [{}] : @input_specs
+      end
+
+      def failure_expected?
+        @failure_expected
+      end
+
+      def focused?
+        @focus
+      end
+
+      def to_s
+        "#{@desc || "#{@kind} #{(@input_specs.map &:to_s).to_sentence } expect #{expected_output}"}"
+      end
+
+    end
+  end
+end
+

data/lib/thoreau/test_suite.rb

@@ -1,24 +1,29 @@
+require_relative './models/appendix'
+require_relative './case/multi_clan_case_builder'
+require 'active_support/core_ext/module/delegation'
+
 module Thoreau
   class TestSuite
 
-    attr_reader :name
-    attr_reader :logger
-
     @@suites = []
 
-    def initialize(context:, logger:, name:, focus:)
-      @context = context
-      @logger  = logger
-      @name    = name
-      @focus   = focus
+    def initialize(data:, focus:)
+      @data  = data
+      @focus = focus
       @@suites << self
-      @builder = Thoreau::Case::Builder.new @context.data.groups, @context
+
+      # @builder = Thoreau::Case::CaseBuilder.new test_clan: @data.test_clan
+      @builder = Thoreau::Case::MultiClanCaseBuilder.new test_clans: @data.test_clans
     end
 
+    delegate :name, to: :@data
+
     def build_and_run
+      logger.debug("## build_and_run")
       cases = @builder.build_test_cases!
+      logger.debug("   ... built #{cases.size} cases")
 
-      runner = Thoreau::Case::Runner.new @context
+      runner = Thoreau::Case::SuiteRunner.new @data.name
       runner.run_test_cases! cases,
                              @builder.skipped_count # for reporting
     end
@@ -28,12 +33,13 @@ module Thoreau
     end
 
     def self.run_all!
+      logger.debug("# run_all! ############")
       run_all = !@@suites.any?(&:focused?)
       @@suites.each do |suite|
         if suite.focused? || run_all
           suite.build_and_run
         else
-          suite.logger.info("Suite '#{suite.name}' skipped (unfocused)")
+          logger.info("   Suite '#{suite.name}' skipped (unfocused)")
         end
       end
     end

data/lib/thoreau/test_suite_data.rb

@@ -0,0 +1,27 @@
+require_relative './models/test_clan'
+
+module Thoreau
+  class TestSuiteData
+
+    include Thoreau::Logging
+
+    attr_accessor :appendix_block
+    attr_reader :test_cases_blocks
+
+    attr_reader :name
+    attr_reader :test_clans
+
+    def initialize name, appendix:, test_clan:
+      @name              = name
+      @appendix          = appendix
+      @test_clans        = [test_clan]
+      @test_cases_blocks = []
+    end
+
+    def add_setup(name, values, block)
+      logger.debug "   Adding setup block #{name}"
+      @appendix.add_setup Thoreau::Models::Setup.new(name, values, block)
+    end
+
+  end
+end