thoreau 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81cb2b1a3e4a3268f26185fd214842eb673f2cda88f7afefeb0153b37d6208a7
-  data.tar.gz: '0815f11d7475d491ae581507f90b474b9bc2765d80ab62d9b2d00440511c7e68'
+  metadata.gz: a8c65711c30e69f7c09e814361f34d2c6b55501223f5b422eed26f23363dd7fb
+  data.tar.gz: dbe902b4cb31334a3afe3a42b3fdde8078eb34ec26c1029fd25ec8825d2c6add
 SHA512:
-  metadata.gz: a364fe16fa6e6cfabeb0a69c60d7619a587e5b4ee2a3b2eb8ce4065eabb3116282d30b9a9683cc205e9b3dd2ae1f2c49ca183cbb1070c173519c9722bdd27c9d
-  data.tar.gz: 61d9e6aff1cdea440a2c34d2611db58c809b13e3c0dd6f54f4abd8bbbadfaa0b8023fbd21c49f09dc72e7b8cb0fccd2023dd910239cd784ab110964ede4e565d
+  metadata.gz: 6ddc80c61cc57201d339e9315df32add749b0219c363b92ce3cfbe8432c8a0076c2a584d8f9feb002202582431b33349c3069200ab44ee36ff7c172bd15df324
+  data.tar.gz: 5e28db2a7a84fc7f9024dca9160115dd9973625f357f4ec499625b2b116e67335590d816b678aed099d20e55e9c4b7928e53d5c828340d886f8f30a6b9544e58

data/lib/thoreau/case/builder.rb

@@ -0,0 +1,110 @@
+module Thoreau
+  class 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 Builder
+
+      def initialize(groups, suite_context)
+        @groups        = groups
+        @suite_context = suite_context
+      end
+
+      def logger
+        @suite_context.logger
+      end
+
+      def any_focused?
+        @groups.count(&:focused?) > 0
+      end
+
+      def skipped_count
+        return 0 unless any_focused?
+        @groups.count - @groups.count(&:focused?)
+      end
+
+      def build_test_cases!
+        logger.debug "build_test_cases!"
+
+        @groups
+          .select { |g| any_focused? && g.focused? || !any_focused? }
+          .flat_map do |g|
+          build_group_cases g
+        end
+      end
+
+      private
+
+      def setup_key_to_inputs key
+        setup = @suite_context.setups[key.to_s]
+        raise "Unrecognized setup context '#{key}'. Available: #{@suite_setups.keys.to_sentence}" if setup.nil?
+
+        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_group_cases g
+        # 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 = g.setups
+                        .map { |key| setup_key_to_inputs key }
+                        .reduce(Hash.new) { |m, h| m.merge(h) }
+
+        input_sets = g.input_specs
+                      .map { |is| setup_values.merge(is) }
+                      .flat_map do |input_spec|
+          explode_input_specs(input_spec.keys, input_spec)
+        end
+
+        input_sets.map do |input_set|
+          Thoreau::Case.new(
+            group:              g,
+            input:              input_set,
+            action:             @suite_context.data.action,
+            expected_output:    g.expected_output,
+            expected_exception: g.expected_exception,
+            asserts:            g.asserts,
+            suite_context:      @suite_context,
+            logger:             logger)
+        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

@@ -0,0 +1,28 @@
+module Thoreau
+  class Case
+    class ContextBuilder
+
+      def initialize(group:, input:)
+        @group        = group
+        @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/runner.rb

@@ -0,0 +1,42 @@
+module Thoreau
+  class Case
+    class Runner
+
+      def initialize(context)
+        @context = context
+      end
+
+      def logger
+        @context.logger
+      end
+
+      def run_test_cases! cases, skipped
+        logger.info "  § #{@context.name} §"
+        cases.each do |c|
+          if c.ok?
+            logger.info "  ✓ #{c.desc}"
+          else
+            logger.error "❓ #{c.desc}, #{c.problem}"
+          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
+          "  ∴ All OK 👌🏾 #{skipped > 0 ? "#{skipped} skipped." : ""}"
+        else
+          " 🛑  #{failed} problem(s) detected.  [#{ok} of #{total} OK#{skipped > 0 ? ", #{skipped} skipped" : ""}.]"
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/thoreau/case.rb

@@ -0,0 +1,97 @@
+require 'active_support/core_ext/module/delegation'
+require_relative './case/context_builder'
+
+module Thoreau
+  class Case
+    def initialize group:,
+                   input:,
+                   action:,
+                   expected_output:,
+                   expected_exception:,
+                   asserts:,
+                   logger:,
+                   suite_context:
+      @group  = group
+      @input  = input
+      @action = action
+      if expected_output.is_a?(Proc)
+        @expected_output_proc = expected_output
+      else
+        @expected_output = expected_output
+      end
+      @expected_exception = expected_exception
+      @assert_proc        = asserts
+      @logger             = logger
+      @suite_context      = suite_context
+      @ran                = false
+    end
+
+    delegate :failure_expected?, to: :@group
+
+    def desc
+      "#{@group.kind}:  #{@group.desc} #{(@input == {} ? nil : @input.sort.to_h) || @expected_exception || "(no args)"}"
+    end
+
+    def problem
+      run unless @ran
+      if @expected_exception
+
+        logger.debug " -> @expected_exception:#{@expected_exception} @raised_exception:#{@raised_exception}"
+
+        if @raised_exception.to_s == @expected_exception.to_s
+          nil
+        elsif @raised_exception.nil?
+          "Expected exception, but none raised"
+        elsif @raised_exception.is_a?(NameError)
+          "Did you forget to define an input? Error: #{@raised_exception}"
+        else
+          "Expected '#{@expected_exception}' exception, but raised '#{@raised_exception}' (#{@raised_exception.class.name})"
+        end
+
+      elsif @assert_proc
+
+        logger.debug " -> @assert_result: #{@assert_result}"
+
+        @assert_result ? nil : "Assertion failed. (got #{@assert_result})"
+      else
+
+        logger.debug " -> @result: #{@result} @expected_output: #{@expected_output} @raised_exception:#{@raised_exception}"
+
+        if @raised_exception
+          "Expected output, but raised exception '#{@raised_exception}'"
+        elsif @expected_output != @result
+          "Expected '#{@expected_output}', but got '#{@result}'"
+        else
+          nil
+        end
+      end
+    end
+
+    def ok?
+      failure_expected? ^ !!problem.nil?
+    end
+
+    def failed?
+      !ok?
+    end
+
+    def run
+      logger.debug("create_context for #{desc} -> ")
+      context_builder = Case::ContextBuilder.new(group: @group, input: @input)
+      context         = context_builder.create_context
+      begin
+        # Only capture exceptions around the action itself.
+        @result = context.instance_exec(&(@action))
+      rescue Exception => e
+        @raised_exception = e
+        return
+      ensure
+        @ran = true
+      end
+
+      @assert_result   = context.instance_exec(@result, &(@assert_proc)) if @assert_proc
+      @expected_output = context.instance_exec(@result, &(@expected_output_proc)) if @expected_output_proc
+    end
+
+  end
+end

data/lib/thoreau/dsl/appendix.rb

@@ -0,0 +1,18 @@
+require_relative '../setup'
+
+module Thoreau
+  module DSL
+    class Appendix
+      def initialize(context)
+        @context = context
+      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)
+      end
+
+    end
+
+  end
+end

data/lib/thoreau/dsl/context.rb

@@ -0,0 +1,55 @@
+module Thoreau
+  module DSL
+    class Data
+      attr_accessor :action
+      attr_accessor :cases
+      attr_accessor :appendix
+      attr_accessor :groups
+
+      def initialize
+        @groups = []
+      end
+    end
+
+    class Context
+
+      attr_reader :data
+      attr_reader :name
+      attr_reader :logger
+      attr_reader :setups
+
+      def initialize name, logger
+        @name   = name
+        @logger = logger
+        @data   = Data.new
+        @setups = {}
+      end
+
+      def action(&block)
+        logger.debug "adding action"
+        @data.action = block
+      end
+
+      alias testing action
+      alias subject action
+
+      def cases(&block)
+        logger.debug "adding cases"
+        @data.cases = block
+      end
+
+      alias test_cases cases
+
+      def appendix(&block)
+        logger.debug "adding appendix"
+        @data.appendix = block
+      end
+
+      def context
+        self
+      end
+
+    end
+
+  end
+end

data/lib/thoreau/dsl/expanded.rb

@@ -0,0 +1,13 @@
+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/groups.rb

@@ -0,0 +1,20 @@
+module Thoreau
+  module DSL
+    class Groups
+
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+      end
+
+      def logger *args
+        @context.logger *args
+      end
+
+      include Thoreau::DSL::GroupsSupport
+
+    end
+
+  end
+end

data/lib/thoreau/dsl/groups_support.rb

@@ -0,0 +1,58 @@
+require_relative '../spec_group'
+require_relative './expanded'
+require 'active_support/core_ext/array/conversions'
+
+module Thoreau
+  module DSL
+
+    SPEC_GROUP_NAMES = %i[happy sad spec edge edges boundary corner gigo]
+    # gigo = garbage in / garbage out
+    #
+    GROUP_PROPS         = %w[assert asserts raises output equal equals expect expects expected legacy pending fails inputs input setup setups].sort.freeze
+    PROPS_SPELL_CHECKER = DidYouMean::SpellChecker.new(dictionary: GROUP_PROPS)
+
+    module GroupsSupport
+      # Note: requires `logger` and `context`.
+      SPEC_GROUP_NAMES.each do |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 || {}
+          spec.keys
+              .reject { |k| GROUP_PROPS.include? k.to_s }
+              .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: #{GROUP_PROPS.to_sentence}"
+          end
+
+          group = SpecGroup.new asserts:            spec[:assert] || spec[:asserts],
+                                desc:               desc,
+                                expected_exception: spec[:raises],
+                                expected_output:    spec[:output] || spec[:equals] || spec[:equal] || spec[:expected] || spec[:expects],
+                                failure_expected:   spec[:pending] || spec[:fails],
+                                input_specs:        [spec[:inputs] || spec[:input] || {}].flatten,
+                                kind:               sym,
+                                legacy:             spec[:legacy],
+                                setups:             [spec[:setup], spec[:setups]].flatten.compact
+          logger.debug "Adding group #{group}"
+          context.data.groups.push(group)
+          group
+        end
+
+        define_method "#{sym}!" do |*args|
+          group       = self.send(sym, *args)
+          group.focus = true
+          group
+        end
+
+        def expanded(a)
+          Thoreau::DSL::Expanded.new(a)
+        end
+      end
+    end
+
+  end
+end

data/lib/thoreau/dsl.rb

@@ -0,0 +1,55 @@
+require 'logger'
+
+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/dsl/appendix'
+
+at_exit do
+  Thoreau::TestSuite.run_all!
+end
+
+module Thoreau
+  module DSL
+
+    attr_reader :logger
+
+    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']
+
+      @context = Thoreau::DSL::Context.new(name, @logger)
+
+      appendix_context = Thoreau::DSL::Appendix.new(@context)
+      groups_context   = Thoreau::DSL::Groups.new(@context)
+
+      @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?
+
+      TestSuite.new(context: @context, focus: focus, logger: logger, name: name)
+    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::GroupsSupport
+
+  end
+end

data/lib/thoreau/legacy_results.rb

@@ -0,0 +1,8 @@
+require 'logger'
+
+module Thoreau
+  class LegacyResults
+
+
+  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/setup.rb

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

data/lib/thoreau/spec_group.rb

@@ -0,0 +1,45 @@
+module Thoreau
+
+  class SpecGroup
+    attr_reader :asserts,
+                :desc,
+                :expected_exception,
+                :expected_output,
+                :input_specs,
+                :kind,
+                :legacy,
+                :setups
+    attr_writer :focus
+
+    def initialize(asserts:,
+                   desc:,
+                   expected_exception:,
+                   expected_output:,
+                   failure_expected:,
+                   input_specs:,
+                   legacy:,
+                   kind:,
+                   setups:
+    )
+      @asserts            = asserts
+      @desc               = desc
+      @expected_exception = expected_exception
+      @expected_output    = expected_output
+      @failure_expected   = failure_expected
+      @input_specs        = input_specs
+      @kind               = kind
+      @legacy             = legacy
+      @setups             = setups
+    end
+
+    def failure_expected?
+      @failure_expected
+    end
+
+    def focused?
+      @focus
+    end
+
+  end
+end
+

data/lib/thoreau/test_suite.rb

@@ -0,0 +1,41 @@
+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
+      @@suites << self
+      @builder = Thoreau::Case::Builder.new @context.data.groups, @context
+    end
+
+    def build_and_run
+      cases = @builder.build_test_cases!
+
+      runner = Thoreau::Case::Runner.new @context
+      runner.run_test_cases! cases,
+                             @builder.skipped_count # for reporting
+    end
+
+    def focused?
+      @focus || @builder.any_focused?
+    end
+
+    def self.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)")
+        end
+      end
+    end
+  end
+end

data/lib/thoreau/util.rb

@@ -0,0 +1,12 @@
+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

data/lib/thoreau/version.rb

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

data/lib/thoreau.rb

@@ -0,0 +1,12 @@
+require_relative 'thoreau/version'
+require_relative 'thoreau/dsl'
+
+module Thoreau
+  class Error < StandardError;
+  end
+  # Your code goes here...
+end
+
+if defined?(RSpec)
+  require_relative('./thoreau/rspec')
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thoreau
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Andrew Peterson
@@ -106,7 +106,27 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/thoreau.rb
+- lib/thoreau/case.rb
+- lib/thoreau/case/builder.rb
+- lib/thoreau/case/context_builder.rb
+- lib/thoreau/case/runner.rb
+- lib/thoreau/dsl.rb
+- lib/thoreau/dsl/appendix.rb
+- lib/thoreau/dsl/context.rb
+- lib/thoreau/dsl/expanded.rb
+- lib/thoreau/dsl/groups.rb
+- lib/thoreau/dsl/groups_support.rb
+- lib/thoreau/legacy_results.rb
+- lib/thoreau/rspec.rb
+- lib/thoreau/rspec/configuration.rb
+- lib/thoreau/rspec/example_helpers.rb
+- lib/thoreau/setup.rb
+- lib/thoreau/spec_group.rb
+- lib/thoreau/test_suite.rb
+- lib/thoreau/util.rb
+- lib/thoreau/version.rb
 homepage: https://github.com/ndp/thoreau
 licenses: []
 metadata: