thoreau 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8c65711c30e69f7c09e814361f34d2c6b55501223f5b422eed26f23363dd7fb
-  data.tar.gz: dbe902b4cb31334a3afe3a42b3fdde8078eb34ec26c1029fd25ec8825d2c6add
+  metadata.gz: 732fd064266fbd5f93dab80bee925ea5a61031de4cfdc82a9015ce5ac0e16c0d
+  data.tar.gz: 82a1e6dabb420fce9d2260c07a7913ecc996838b3f4e0d98f2f5a8938cafcdaa
 SHA512:
-  metadata.gz: 6ddc80c61cc57201d339e9315df32add749b0219c363b92ce3cfbe8432c8a0076c2a584d8f9feb002202582431b33349c3069200ab44ee36ff7c172bd15df324
-  data.tar.gz: 5e28db2a7a84fc7f9024dca9160115dd9973625f357f4ec499625b2b116e67335590d816b678aed099d20e55e9c4b7928e53d5c828340d886f8f30a6b9544e58
+  metadata.gz: ac549caf454efbc7d6e5806176897dd10a93177c34bea768f27030a49ed1c2da3bf8ad63ee86deb45ee4f5148a48f136f04ad24cacc63b921c03cdcd0912be37
+  data.tar.gz: 1acaf812da2937c14ae7b509fcdd96bf0c3211b4eeaa06eabe97ce032c1d50401915e316bfa3a39558e78895646fb11186c18fa0c730e45dd9f5a3c04f7a7577

data/lib/thoreau/auto_run.rb

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

data/lib/thoreau/case/case_builder.rb

@@ -0,0 +1,114 @@
+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 setup_key_to_inputs key
+        setup = @appendix.setups[key.to_s]
+        raise "Unrecognized setup context '#{key}'. Available: #{@appendix.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
+
+      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 = fam.setups
+                          .map { |key| setup_key_to_inputs key }
+                          .reduce(Hash.new) { |m, h| m.merge(h) }
+        logger.debug("   -> setup_values = #{setup_values}")
+        logger.debug("   -> fam.input_specs = #{fam.input_specs}")
+        input_sets = fam.input_specs
+                        .map { |is| setup_values.merge(is) }
+                        .flat_map do |input_spec|
+          explode_input_specs(input_spec.keys, input_spec)
+        end
+        input_sets = [{}] if input_sets.size == 0
+        logger.debug("   -> input_sets: #{input_sets}")
+        logger.debug("   build cases for '#{fam.desc}', #{setup_values.size} setups, #{input_sets.size} input sets, build_family_cases")
+
+        input_sets.map do |input_set|
+          expectation = fam.use_legacy_snapshot ?
+                          :use_legacy_snapshot :
+                          Models::Outcome.new(output:    fam.expected_output,
+                                              exception: fam.expected_exception)
+
+          Thoreau::Models::TestCase.new family_desc:  "#{fam.kind.to_s.ljust(10).capitalize} #{fam.desc}",
+                                        input:        input_set,
+                                        action_block: @action_block,
+                                        expectation:  expectation,
+                                        asserts:      fam.asserts,
+                                        negativo:     fam.failure_expected?
+        end
+
+      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

@@ -1,10 +1,9 @@
 module Thoreau
-  class Case
+  module Case
     class ContextBuilder
 
-      def initialize(group:, input:)
-        @group        = group
-        @input        = input
+      def initialize(input:)
+        @input = input
       end
 
       def create_context

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(name)
+        @suite_name = 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 = './tmp/legacy-outcomes.pstore'
+    end
+  end
+end

data/lib/thoreau/dsl/appendix.rb

@@ -1,15 +1,15 @@
-require_relative '../setup'
+require_relative '../models/setup'
 
 module Thoreau
   module DSL
     class Appendix
-      def initialize(context)
-        @context = context
+      def initialize(appendix_model, &appendix_block)
+        @model = appendix_model
+        self.instance_eval(&appendix_block)
       end
 
       def setup name, values = {}, &block
-        raise "duplicate setup block #{name}" unless @context.setups[name].nil?
-        @context.setups[name.to_s] = Thoreau::Setup.new(name, values, block)
+        @model.add_setup(name, values, block)
       end
 
     end

data/lib/thoreau/dsl/clan.rb

@@ -0,0 +1,94 @@
+require_relative '../models/test_family'
+require_relative './expanded'
+require_relative '../util'
+require 'active_support/core_ext/array/conversions'
+
+module Thoreau
+  module DSL
+
+    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]
+    }
+    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 action block"
+        @test_clan_model.action_block = block
+      end
+      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 = Models::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

data/lib/thoreau/dsl/suite_context.rb

@@ -0,0 +1,46 @@
+require_relative '../test_suite_data'
+require 'active_support/core_ext/module/delegation'
+
+module Thoreau
+  module DSL
+
+    class SuiteContext
+
+      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
+
+      def context
+        self
+      end
+
+      def add_test_family family
+        suite_data.add_test_family family
+      end
+
+    end
+
+  end
+end

data/lib/thoreau/dsl/test_cases.rb

@@ -0,0 +1,20 @@
+module Thoreau
+  module DSL
+    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::Clan
+
+    end
+
+  end
+end

data/lib/thoreau/dsl.rb

@@ -1,40 +1,53 @@
-require 'logger'
-
+require 'thoreau/logging'
 require 'thoreau/test_suite'
-require 'thoreau/case'
-require 'thoreau/case/builder'
-require 'thoreau/case/runner'
-require 'thoreau/dsl/groups_support'
-require 'thoreau/dsl/context'
-require 'thoreau/dsl/groups'
+require 'thoreau/models/test_case'
+require 'thoreau/models/test_clan'
+require 'thoreau/case/case_builder'
+require 'thoreau/case/suite_runner'
+require 'thoreau/dsl/clan'
+require 'thoreau/dsl/suite_context'
+require 'thoreau/dsl/test_cases'
 require 'thoreau/dsl/appendix'
-
-at_exit do
-  Thoreau::TestSuite.run_all!
-end
+require_relative './errors'
 
 module Thoreau
+
   module DSL
 
-    attr_reader :logger
+    include Thoreau::Logging
+
+    attr_reader :suite_data
 
     def test_suite name = nil, focus: false, &block
-      @logger      = Logger.new(STDOUT, formatter: proc { |severity, datetime, progname, msg|
-        "#{severity}: #{msg}\n"
-      })
-      logger.level = Logger::INFO
-      logger.level = Logger::DEBUG if ENV['DEBUG']
+      logger.debug("# Processing keyword `test_suite`")
+
+      appendix        = Models::Appendix.new
+      top_level_clan_model = Thoreau::Models::TestClan.new name, appendix: appendix
+      @suite_data     = TestSuiteData.new name, test_clan: top_level_clan_model, appendix: appendix
+
+      # Evaluate all the top-level keywords: test_cases, appendix
+      @suite_context = Thoreau::DSL::SuiteContext.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::Appendix.new(@suite_data, &appendix_block) unless appendix_block.nil?
 
-      @context = Thoreau::DSL::Context.new(name, @logger)
+      logger.debug("## Evaluating test_cases blocks")
+      @suite_data.test_cases_blocks.each do |name, cases_block|
 
-      appendix_context = Thoreau::DSL::Appendix.new(@context)
-      groups_context   = Thoreau::DSL::Groups.new(@context)
+        raise TestCasesAtMultipleLevelsError unless @suite_data.test_clans.first.empty?
 
-      @context.instance_eval(&block)
-      appendix_context.instance_eval(&@context.data.appendix) unless @context.data.appendix.nil?
-      groups_context.instance_eval(&@context.data.cases) unless @context.data.cases.nil?
+        test_clan_model = Thoreau::Models::TestClan.new name,
+                                                        appendix: appendix,
+                                                        action_block: top_level_clan_model.action_block
+        Thoreau::DSL::TestCases.new(test_clan_model, &cases_block)
+        @suite_data.test_clans << test_clan_model
+      end
 
-      TestSuite.new(context: @context, focus: focus, logger: logger, name: name)
+      TestSuite.new(data: @suite_data, focus: focus)
     end
 
     def xtest_suite name = nil, &block
@@ -49,7 +62,7 @@ module Thoreau
 
     alias suite! test_suite!
 
-    include Thoreau::DSL::GroupsSupport
+    include Thoreau::DSL::Clan
 
   end
 end