thoreau 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81cb2b1a3e4a3268f26185fd214842eb673f2cda88f7afefeb0153b37d6208a7
-  data.tar.gz: '0815f11d7475d491ae581507f90b474b9bc2765d80ab62d9b2d00440511c7e68'
+  metadata.gz: d712bdb1cef5f616159042ee63dba2694717f2b60d0fa8b72994f5568d23ef7a
+  data.tar.gz: 61d14f95c9344a58cd68cb96bf0123679a9aa67d0a08d71859473bf3774fd7c1
 SHA512:
-  metadata.gz: a364fe16fa6e6cfabeb0a69c60d7619a587e5b4ee2a3b2eb8ce4065eabb3116282d30b9a9683cc205e9b3dd2ae1f2c49ca183cbb1070c173519c9722bdd27c9d
-  data.tar.gz: 61d9e6aff1cdea440a2c34d2611db58c809b13e3c0dd6f54f4abd8bbbadfaa0b8023fbd21c49f09dc72e7b8cb0fccd2023dd910239cd784ab110964ede4e565d
+  metadata.gz: dd809493f3ec81b435849c64409a595fee425dcf6952ab636d682a3ff52d1df46eeed1f46e5c0f1daf3a1c208207306b51a6c365dcefb4a7a7d24e5cdb39c8d0
+  data.tar.gz: 510efd7e19530338004efb17dba5fe94e22d9d51bbd12fcf02ec60e8eee4b061d44771b08ae82781b45effd37428647c62e65af803dc551a29b1578cf441ceb1

data/lib/thoreau/auto_run.rb

@@ -0,0 +1,6 @@
+require_relative '../thoreau'
+require_relative './dsl'
+
+at_exit do
+  Thoreau::Model::TestSuite.run_all!
+end

data/lib/thoreau/case/case_builder.rb

@@ -0,0 +1,110 @@
+module Thoreau
+  module Case
+    # Build test cases.
+    #
+    # It is responsible for:
+    # - building an list of Test::Case objects based
+    #   on the groups provided.
+    # - expanding input specs in the groups into multiple cases
+    # - skipping unfocused tests, if any are focused
+    # - returning a count of those skipped
+    class CaseBuilder
+
+      include Logging
+
+      def initialize(test_clan:)
+        logger.debug("CaseBuilder.new #{test_clan.name} #{test_clan.test_families.size} families")
+        @test_families = test_clan.test_families
+        @action_block  = test_clan.action_block
+        @appendix      = test_clan.appendix
+      end
+
+      def any_focused?
+        @test_families.count(&:focused?) > 0
+      end
+
+      def skipped_count
+        return 0 unless any_focused?
+        @test_families.count - @test_families.count(&:focused?)
+      end
+
+      def build_test_cases!
+        logger.debug "   build_test_cases! (#{@test_families.size} families)"
+
+        @test_families
+          .select { |fam| any_focused? && fam.focused? || !any_focused? }
+          .flat_map { |fam| build_family_cases fam }
+      end
+
+      private
+
+      def build_family_cases fam
+        # We have "specs" for the inputs. These may be actual
+        # values, or they may be enumerables that need to execute.
+        # So we need to "explode" (or enumerate) the values,
+        # generating a single test for each combination.
+        #
+        setup_values = @appendix.setup_values fam.setups
+
+        # calculate the inputs, expanded from the setup values above
+        input_hashes = build_input_hashes fam.input_specs, setup_values
+
+        logger.debug("   -> setup_values = #{setup_values}")
+        logger.debug("   -> fam.input_specs = #{fam.input_specs}")
+        logger.debug("   -> input_sets: #{input_hashes}")
+        logger.debug("   build cases for '#{fam.desc}', #{setup_values.size} setups, #{input_hashes.size} input sets, build_family_cases")
+
+        input_hashes.map do |input_hash|
+          expectation = fam.use_legacy_snapshot ?
+                          :use_legacy_snapshot :
+                          Model::Outcome.new(output:    fam.expected_output,
+                                              exception: fam.expected_exception)
+
+          Thoreau::Model::TestCase.new family_desc:  "#{fam.kind.to_s.ljust(10).capitalize} #{fam.desc}",
+                                        input:        input_hash,
+                                        action_block: @action_block,
+                                        expectation:  expectation,
+                                        asserts:      fam.asserts,
+                                        negativo:     fam.failure_expected?
+        end
+
+      end
+
+
+      def build_input_hashes input_specs, setup_values
+        sets = input_specs
+                 .map { |is| setup_values.merge(is) }
+                 .flat_map do |input_spec|
+          explode_input_specs(input_spec.keys, input_spec)
+        end
+        sets = [{}] if sets.size == 0
+        sets
+      end
+
+      # Expand any values that are enumerators (Thoreau::DSL::Expanded),
+      # creating a list of objects, where all the combinations
+      # of enumerated values are present.
+      def explode_input_specs(keys, input_spec)
+        k = keys.pop
+
+        value_spec = input_spec[k]
+        specs      = if value_spec.is_a?(Thoreau::DSL::Expanded)
+                       value_spec.map do |v|
+                         input_spec.merge(k => v)
+                       end
+                     else
+                       [input_spec]
+                     end
+
+        # Are we done?
+        return specs if keys.empty?
+
+        specs.flat_map do |spec|
+          explode_input_specs(keys, spec) # recurse!
+        end
+
+      end
+
+    end
+  end
+end

data/lib/thoreau/case/context_builder.rb

@@ -0,0 +1,27 @@
+module Thoreau
+  module Case
+    class ContextBuilder
+
+      def initialize(input:)
+        @input = input
+      end
+
+      def create_context
+        temp_class   = Class.new
+        temp_context = temp_class.new
+        inject_hash_into_context(@input, temp_context)
+        temp_context
+      end
+
+      private
+
+      def inject_hash_into_context(h, temp_context)
+        h.each do |lval, rval|
+          temp_context.instance_variable_set("@#{lval}", rval)
+          temp_context.class.attr_accessor lval
+        end
+      end
+
+    end
+  end
+end

data/lib/thoreau/case/multi_clan_case_builder.rb

@@ -0,0 +1,27 @@
+module Thoreau
+  module Case
+    class MultiClanCaseBuilder
+
+      include Logging
+
+      def initialize(test_clans:)
+        @case_builders = test_clans.map do |test_clan|
+          CaseBuilder.new test_clan: test_clan
+        end
+      end
+
+      def any_focused?
+        @case_builders.any? &:any_focused?
+      end
+
+      def skipped_count
+        return 0 unless any_focused?
+        @case_builders.map(&:skipped_count).reduce(&:+)
+      end
+
+      def build_test_cases!
+        @case_builders.flat_map(&:build_test_cases!)
+      end
+    end
+  end
+end

data/lib/thoreau/case/suite_runner.rb

@@ -0,0 +1,61 @@
+require 'rainbow/refinement'
+using Rainbow
+
+module Thoreau
+  module Case
+    class SuiteRunner
+
+      include Logging
+
+      def initialize(suite_name)
+        @suite_name = suite_name
+      end
+
+      def run_test_cases! cases, skipped
+        legacy_data = LegacyExpectedOutcomes.new(@suite_name)
+        logger.info "     #{@suite_name.underline.bright}"
+        cases.each do |c|
+
+          legacy = c.expectation == :use_legacy_snapshot
+          if legacy
+            if !legacy_data.has_saved_for?(c) ||
+              ENV['RESET_SNAPSHOTS']
+              logger.info "     [#{ENV['RESET_SNAPSHOTS'] ? 'resetting' : 'saving'} legacy data]"
+              c.run
+              c.expectation = c.actual # by definition
+              legacy_data.save!(c)
+            else
+              c.expectation = legacy_data.load_for c
+            end
+          end
+
+          c.run
+
+          if c.ok?
+            logger.info "  #{legacy ? '▶️ ' : '✓ ' } #{c.desc}"
+          else
+            logger.error "❓  #{c.desc.bright}"
+            logger.error "    #{c.problem.red.bright}"
+          end
+        end
+        logger.info (summary cases, skipped)
+        logger.info ""
+
+      end
+
+      def summary cases, skipped
+        ok     = cases.count(&:ok?)
+        total  = cases.count
+        failed = cases.count(&:failed?)
+        if failed == 0
+          "  ∴  No problems detected 👌🏾 #{skipped > 0 ? "#{skipped} skipped." : ""}"
+        else
+          " 🛑  #{failed} problem(s) detected.  [#{ok} of #{total} OK#{skipped > 0 ? ", #{skipped} skipped" : ""}.]".bright
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/thoreau/configuration.rb

@@ -0,0 +1,9 @@
+module Thoreau
+  class Configuration
+    attr_accessor :legacy_outcome_path
+
+    def initialize
+      @legacy_outcome_path = './spec/legacy-outcomes.pstore'
+    end
+  end
+end

data/lib/thoreau/dsl/context/appendix.rb

@@ -0,0 +1,17 @@
+module Thoreau
+  module DSL
+    module Context
+      class Appendix
+        def initialize(appendix_model, &appendix_block)
+          @model = appendix_model
+          self.instance_eval(&appendix_block)
+        end
+
+        def setup name, values = {}, &block
+          @model.add_setup(name, values, block)
+        end
+
+      end
+    end
+  end
+end

data/lib/thoreau/dsl/context/clan.rb

@@ -0,0 +1,97 @@
+require_relative '../../model/test_family'
+require_relative '../expanded'
+require_relative '../../service/util'
+require 'active_support'
+require 'active_support/core_ext/array/conversions'
+
+module Thoreau
+  module DSL
+    module Context
+
+      SPEC_FAMILY_NAMES = %i[happy sad spec test edge edges boundary corner gigo]
+      # gigo = garbage in / garbage out
+      #
+      PROPS               = {
+        asserts:            %i[assert asserts post post_condition],
+        expected_exception: %i[raises],
+        expected_output:    %i[equals equal expected expect expects output],
+        failure_expected:   %i[fails pending],
+        input_specs:        %i[input inputs],
+        setups:             %i[setup setups assemble]
+      }
+      ALL_PROPS           = PROPS.values.flatten.map(&:to_s)
+      PROPS_SPELL_CHECKER = DidYouMean::SpellChecker.new(dictionary: ALL_PROPS)
+
+      module Clan
+
+        # Note: requires `@test_clan_model`.
+
+        def action(&block)
+          logger.debug "   + Adding subject block"
+          @test_clan_model.action_block = block
+        end
+
+        alias act action
+        alias testing action
+        alias subject action
+
+        def self.def_family_methods_for(sym)
+          define_method sym do |*args|
+            desc = args.shift if args.size > 1 && args.first.is_a?(String)
+            raise "Too many arguments to #{sym}!" if args.size > 1
+
+            spec = args.first&.stringify_keys || {}
+            spec.keys
+                .reject { |k| ALL_PROPS.include? k }
+                .each do |k|
+              suggestions = PROPS_SPELL_CHECKER.correct(k)
+              logger.error "Ignoring unrecognized property '#{k}'."
+              logger.info "    Did you mean #{suggestions.to_sentence}?" if suggestions.size > 0
+              logger.info "    Available properties: #{ALL_PROPS.to_sentence}"
+            end
+
+            params = HashUtil.normalize_props(spec.symbolize_keys, PROPS).tap { |props|
+              # These two props are easier to deal with downstream as empty arrays
+              props[:input_specs] = [props[:input_specs]].flatten.compact
+              props[:setups]      = [props[:setups]].flatten.compact
+            }.merge kind: sym,
+                    desc: desc
+
+            family = Model::TestFamily.new **params
+
+            yield family if block_given?
+
+            logger.debug "   * Created new family #{params.inspect}"
+            @test_clan_model.add_test_family family
+          end
+
+          define_method "#{sym}!" do |*args|
+            family       = self.send(sym, *args)
+            family.focus = true
+            family
+          end
+        end
+
+        SPEC_FAMILY_NAMES.each do |sym|
+          def_family_methods_for sym
+        end
+
+        def_family_methods_for :legacy do |r|
+          r.use_legacy_snapshot = true
+        end
+
+        alias legacy_spec legacy
+        alias legacy_test legacy
+        alias legacy_code legacy
+        alias legacy_spec! legacy!
+        alias legacy_test! legacy!
+        alias legacy_code! legacy!
+
+        def expanded(a)
+          Thoreau::DSL::Expanded.new(a)
+        end
+
+      end
+    end
+  end
+end

data/lib/thoreau/dsl/context/suite.rb

@@ -0,0 +1,40 @@
+require 'active_support'
+require 'active_support/core_ext/module/delegation'
+
+module Thoreau
+  module DSL
+  module Context
+
+    class Suite
+
+      include Thoreau::Logging
+
+      attr_reader :suite_data
+      attr_reader :test_clan_model
+
+      def initialize suite_data:, test_clan_model:
+        raise "Suites must have (unique) names." if suite_data.name.blank?
+        @suite_data = suite_data
+        @test_clan_model  = test_clan_model
+      end
+
+      delegate :name, to: :suite_data
+
+      def cases(name = nil, &block)
+        name = self.suite_data.name if name.nil?
+        logger.debug "   + adding cases named `#{name}`"
+        @suite_data.test_cases_blocks << [name, block]
+      end
+
+      alias test_cases cases
+
+      def appendix(&block)
+        logger.debug "   adding appendix block"
+        @suite_data.appendix_block = block
+      end
+
+    end
+
+  end
+end
+end

data/lib/thoreau/dsl/context/test_cases.rb

@@ -0,0 +1,21 @@
+module Thoreau
+  module DSL
+    module Context
+      class TestCases
+
+        include Thoreau::Logging
+
+        attr_reader :test_clan_model
+
+        def initialize(clan_model, &context)
+          @test_clan_model = clan_model
+
+          self.instance_eval(&context)
+        end
+
+        include Thoreau::DSL::Context::Clan
+
+      end
+    end
+  end
+end

data/lib/thoreau/dsl/expanded.rb

@@ -0,0 +1,14 @@
+require 'active_support'
+require 'active_support/core_ext/module/delegation'
+
+module Thoreau
+  module DSL
+    class Expanded
+      def initialize a
+        @a = a
+      end
+
+      delegate :map, :each, to: :@a
+    end
+  end
+end

data/lib/thoreau/dsl/test_suite_data.rb

@@ -0,0 +1,29 @@
+require_relative '../model/setup'
+
+module Thoreau
+  module DSL
+    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::Model::Setup.new(name, values, block)
+      end
+
+    end
+  end
+end

data/lib/thoreau/dsl.rb

@@ -0,0 +1,69 @@
+require 'thoreau/service/logging'
+require 'thoreau/model/test_suite'
+require 'thoreau/model/test_case'
+require 'thoreau/model/test_clan'
+require 'thoreau/case/case_builder'
+require 'thoreau/case/suite_runner'
+require 'thoreau/dsl/test_suite_data'
+require 'thoreau/dsl/context/clan'
+require 'thoreau/dsl/context/suite'
+require 'thoreau/dsl/context/test_cases'
+require 'thoreau/dsl/context/appendix'
+require_relative './errors'
+
+module Thoreau
+
+  module DSL
+
+    include Thoreau::Logging
+
+    attr_reader :suite_data
+
+    def test_suite name = nil, focus: false, &block
+      logger.debug("# Processing keyword `test_suite`")
+
+      appendix        = Model::Appendix.new
+      top_level_clan_model = Thoreau::Model::TestClan.new name, appendix: appendix
+      @suite_data     = Thoreau::DSL::TestSuiteData.new name, test_clan: top_level_clan_model, appendix: appendix
+
+      # Evaluate all the top-level keywords: test_cases, appendix
+      @suite_context = Thoreau::DSL::Context::Suite.new suite_data:      @suite_data,
+                                                      test_clan_model: top_level_clan_model
+      logger.debug("## Evaluating suite")
+      @suite_context.instance_eval(&block)
+
+      logger.debug("## Evaluating appendix block")
+      appendix_block = @suite_data.appendix_block
+      Thoreau::DSL::Context::Appendix.new(@suite_data, &appendix_block) unless appendix_block.nil?
+
+      logger.debug("## Evaluating test_cases blocks")
+      @suite_data.test_cases_blocks.each do |name, cases_block|
+
+        raise TestCasesAtMultipleLevelsError unless @suite_data.test_clans.first.empty?
+
+        test_clan_model = Thoreau::Model::TestClan.new name,
+                                                        appendix: appendix,
+                                                        action_block: top_level_clan_model.action_block
+        Thoreau::DSL::Context::TestCases.new(test_clan_model, &cases_block)
+        @suite_data.test_clans << test_clan_model
+      end
+
+      Model::TestSuite.new(data: @suite_data, focus: focus)
+    end
+
+    def xtest_suite name = nil, &block
+    end
+
+    alias suite test_suite
+    alias xsuite xtest_suite
+
+    def test_suite! name = nil, &block
+      test_suite name, focus: true, &block
+    end
+
+    alias suite! test_suite!
+
+    include Thoreau::DSL::Context::Clan
+
+  end
+end

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/model/appendix.rb

@@ -0,0 +1,37 @@
+module Thoreau
+  module Model
+    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
+
+      def setup_values keys
+        keys
+          .map { |key| self.setup_key_to_inputs key }
+          .reduce(Hash.new) { |m, h| m.merge(h) }
+      end
+
+      private
+
+      def setup_key_to_inputs key
+        setup = self.setups[key.to_s]
+        raise "Unrecognized setup context '#{key}'. Available: #{self.setups.keys.to_sentence}" if setup.nil?
+        logger.debug("   setup_key_to_inputs `#{key}`: #{setup}")
+        return setup.values if setup.block.nil?
+
+        result = Class.new.new.instance_eval(&setup.block)
+        logger.error "Setup #{key} did not return a hash object" unless result.is_a?(Hash)
+        result
+      end
+
+    end
+  end
+end

data/lib/thoreau/model/outcome.rb

@@ -0,0 +1,33 @@
+module Thoreau
+  module Model
+    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/model/setup.rb

@@ -0,0 +1,17 @@
+module Thoreau
+  module Model
+
+    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/model/test_case.rb

@@ -0,0 +1,131 @@
+require 'active_support'
+require 'active_support/core_ext/module/delegation'
+require_relative '../case/context_builder'
+require_relative './outcome'
+require_relative '../service/legacy_expected_outcomes'
+
+module Thoreau
+  module Model
+    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 result_analysis
+
+        run unless @ran
+
+        if @expectation.exception
+
+          logger.debug " -> Expected Exception #{@expectation.exception} @actual.exception:#{@actual.exception}"
+
+          if @expectation.exception.is_a?(Class) &&
+            @actual.exception.class == @expectation.exception
+            nil
+          elsif @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}"
+
+          if @actual.exception.nil?
+            @assert_result ? nil : "Assertion failed. (got '#{@assert_result}', result='#{@actual.output}')"
+          else
+            "Expected assertion, but raised exception '#{@actual.exception}'"
+          end
+
+        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 problem
+        if failure_expected?
+          if result_analysis.nil?
+            "Failure expected but didn't. Is this implemented already?"
+          else
+            nil
+          end
+        else
+          result_analysis
+        end
+      end
+
+      def ok?
+        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 subject itself.
+          output  = context.instance_exec(&(@action_block))
+          @actual = Model::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 = Model::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/model/test_clan.rb

@@ -0,0 +1,38 @@
+require 'active_support'
+require 'active_support/core_ext/module/delegation'
+require_relative '../errors'
+
+module Thoreau
+
+  module Model
+    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/model/test_family.rb

@@ -0,0 +1,53 @@
+module Thoreau
+  module Model
+
+    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/model/test_suite.rb

@@ -0,0 +1,50 @@
+require 'active_support'
+require 'active_support/core_ext/module/delegation'
+require_relative './appendix'
+require_relative '../case/multi_clan_case_builder'
+
+module Thoreau
+  module Model
+    class TestSuite
+
+      @@suites = []
+
+      def initialize(data:, focus:)
+        @data  = data
+        @focus = focus
+        @@suites << self
+
+        # @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::SuiteRunner.new @data.name
+        runner.run_test_cases! cases,
+                               @builder.skipped_count # for reporting
+      end
+
+      def focused?
+        @focus || @builder.any_focused?
+      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
+            logger.info("   Suite '#{suite.name}' skipped (unfocused)")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thoreau/rspec/configuration.rb

@@ -0,0 +1,14 @@
+module Thoreau
+  module Rspec
+
+    class Configuration
+
+      def initialize(rspec_config)
+        @rspec_config = rspec_config
+      end
+
+      class ConfigurationError < StandardError;
+      end
+    end
+  end
+end

data/lib/thoreau/rspec/example_helpers.rb

@@ -0,0 +1,7 @@
+
+module Thoreau
+  module Rspec
+    module ExampleHelpers
+    end
+  end
+end

data/lib/thoreau/rspec.rb

@@ -0,0 +1,19 @@
+
+require 'rspec/core'
+require 'thoreau'
+require 'thoreau/rspec/example_helpers'
+require 'thoreau/rspec/configuration'
+require 'thoreau/rspec/railtie' if defined?(Rails::Railtie)
+
+module Thoreau
+  module Rspec
+
+    ::RSpec.configure do |c|
+      c.include ExampleHelpers
+    end
+
+    def self.config
+      @config ||= Configuration.new(RSpec.configuration)
+    end
+  end
+end

data/lib/thoreau/service/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/service/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/service/util.rb

@@ -0,0 +1,41 @@
+def combos_of(entries)
+  return [{}] if entries.size == 0
+
+  first_response = entries.first.map { |x| { x[0] => x[1] } }
+  return first_response if entries.size == 1
+
+  combos_of_rest = combos_of(entries.slice(1..(entries.size)))
+
+  first_response.flat_map do |f|
+    combos_of_rest.map { |r| r.merge(f) }
+  end
+end
+
+module Thoreau
+  class HashUtil
+
+    # prop_map is a map from canonical property name to all versions
+    def self.normalize_props(hash, prop_map, include_all_normalized_props = true)
+      prop_map.reduce(Hash.new) do |memo, (k, v)|
+        value   = one_of_these(hash, v, include_all_normalized_props ? nil : :secret_default_value)
+        memo[k] = value unless value == :secret_default_value
+        memo
+      end
+    end
+
+    def self.one_of_these(hash, pick_one_of_these_keys, default_value = nil)
+      keys_present = pick_one_of_these_keys.intersection hash.keys
+
+      if keys_present.size > 1
+        logger.error "Only of of these keys is allowed: #{keys_present.to_sentence}"
+      end
+
+      pick_one_of_these_keys.each do |k|
+        return hash[k] if hash.key?(k)
+      end
+
+      default_value
+    end
+
+  end
+end

data/lib/thoreau/version.rb

@@ -0,0 +1,3 @@
+module Thoreau
+  VERSION = "0.3.1"
+end

data/lib/thoreau.rb

@@ -0,0 +1,18 @@
+require_relative 'thoreau/version'
+require_relative 'thoreau/dsl'
+require_relative 'thoreau/configuration'
+
+module Thoreau
+  def self.configure &block
+    block.call configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+end
+
+if defined?(RSpec)
+  require_relative('./thoreau/rspec')
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thoreau
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrew Peterson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-02 00:00:00.000000000 Z
+date: 2021-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
-    - - "<"
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -106,7 +114,36 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/thoreau.rb
+- lib/thoreau/auto_run.rb
+- lib/thoreau/case/case_builder.rb
+- lib/thoreau/case/context_builder.rb
+- lib/thoreau/case/multi_clan_case_builder.rb
+- lib/thoreau/case/suite_runner.rb
+- lib/thoreau/configuration.rb
+- lib/thoreau/dsl.rb
+- lib/thoreau/dsl/context/appendix.rb
+- lib/thoreau/dsl/context/clan.rb
+- lib/thoreau/dsl/context/suite.rb
+- lib/thoreau/dsl/context/test_cases.rb
+- lib/thoreau/dsl/expanded.rb
+- lib/thoreau/dsl/test_suite_data.rb
+- lib/thoreau/errors.rb
+- lib/thoreau/model/appendix.rb
+- lib/thoreau/model/outcome.rb
+- lib/thoreau/model/setup.rb
+- lib/thoreau/model/test_case.rb
+- lib/thoreau/model/test_clan.rb
+- lib/thoreau/model/test_family.rb
+- lib/thoreau/model/test_suite.rb
+- lib/thoreau/rspec.rb
+- lib/thoreau/rspec/configuration.rb
+- lib/thoreau/rspec/example_helpers.rb
+- lib/thoreau/service/legacy_expected_outcomes.rb
+- lib/thoreau/service/logging.rb
+- lib/thoreau/service/util.rb
+- lib/thoreau/version.rb
 homepage: https://github.com/ndp/thoreau
 licenses: []
 metadata: