theorem 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82f4b3d0f32345396cdbc66fc1d28d00d014f3576c8cf36e18eb355913fd34cd
-  data.tar.gz: ac2241928677901a46a9e12fb980e7a787f9e43ede2c7bf862a0bb3277fe6527
+  metadata.gz: 91647688dc2f743ee8d64461f26ee5f2265be617c82623a97e0cfd7cdec58aa8
+  data.tar.gz: 410086697fb9d6718c3f05a64cbac277b59fa4ced15cf679484b9eed11bb9edf
 SHA512:
-  metadata.gz: 2233e6daab124321a5f83dda68b09b8159f1561afb5b9cb8c2f1b626170dce551ed1a833164fc2e58cc5a02a86f216b0be95057b4f8aee6b2c986c3928c10837
-  data.tar.gz: 7b4432d63c2a4bdc6c18875b7fdecc27cb14412fcdbaf8d3867fd31863ff8173faa21d2e1b37db65848af72571e7656ebf5ce0a31ed8d21697f2412a9f052976
+  metadata.gz: f66749de7a52cee707d0c149e7e9b273d05b46248a69e7acb4f3669d400e6a833fcac9d268eb0f87acd6f5b3cbc9d8c5bfaa836491d705c8666563ae9dfe6fe8
+  data.tar.gz: dc737567dc4303c362f5dcb3bfa6a75474981d6b355367b6d8d711c4ad5170c8f3e0c0cf252197f4007ef16f9e403234f75277559e3d9ff8ce908cc5faff94e9

data/bin/theorize

@@ -1,5 +1,18 @@
 #!/usr/bin/ruby
 
-require_relative '../src/harness'
+require 'slop'
+require_relative '../src/theorem'
 
-Theorem::Hypothesis::Harness.run! ARGV[0] || '.'
+opts = Slop.parse do |o|
+  o.array '--require', 'files to require', delimiter: ','
+  o.string '-m', '--module', 'module (default: Theorem::Hypothesis)', default: 'Theorem::Hypothesis'
+  o.string '-h', '--harness', 'harness (default: Theorem::Harness)', default: 'Theorem::Harness'
+  o.array '-p', '--publisher', 'publishers (default: Theorem::StdoutReporter)', delimiter: ',', default: ['Theorem::StdoutReporter']
+  o.string '-d', '--directory', 'directory to load tests (default: ".")', default: '.'
+  o.on '--help' do
+    puts o
+    exit
+  end
+end
+
+Theorem.run! opts

data/src/experiment.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Theorem
+  # shared examples
+  class Experiment
+    class << self
+      def test(name, &block)
+        @tests ||= []
+        @tests << { name: name, block: block }
+      end
+
+      def tests(_experiment_namespace: to_s, **opts)
+        @tests.map do |hash|
+          Control::Test.new(hash[:name], _experiment_namespace, **opts, &hash[:block])
+        end
+      end
+    end
+  end
+end

data/src/harness.rb

@@ -1,40 +1,33 @@
-require_relative './hypothesis'
-require 'extended_dir'
+# frozen_string_literal: true
 
-# module
-module Theorem
-  module Hypothesis
-    on_completed_test do |test|
-      print test.failed? ? 'X' : '.'
-    end
-
-    # harness
-    class Harness
-      def self.locate_tests(dir)
-        ExtendedDir.require_all("./#{dir}")
-
-        Hypothesis.registry
-      end
+require_relative './theorem/harness'
 
-      def self.run!(dir)
-        test_cases = locate_tests(dir)
-        total_count = test_cases.map do |test_case|
-          test_case.tests.size
-        end.inject(&:+)
-
-        puts "Total tests #{total_count}"
+# harness
+module Theorem
+  # default test harness
+  module Harness
+    include Control::Harness
+  end
 
-        results = test_cases.map(&:run!).flatten
+  # module retry harness
+  module RetryHarness
+    include Control::Harness
 
-        puts "\n\nSummary\n-------"
+    on_run do |tests|
+      arr_of_tests = tests.map { |test| { test: test, index: 0 } }
 
-        failed_tests = results.select(&:failed?)
-        failed_tests.each do |failure|
-          puts "Failure in #{failure.name}\nError: #{failure.error}\nBacktrace:\n------\n#{failure.error.backtrace.join("\n")}"
+      final_results = []
+      arr_of_tests.each do |test|
+        test[:index] += 1
+        results = test[:test].run!
+        if results.any?(&:failed?) && test[:index] <= 3
+          puts "Retrying iteration: #{test[:index]}\n#{results.map(&:full_name).join("\n")}"
+          redo
         end
-
-        exit failed_tests.any? ? 1 : 0
+        final_results.concat results
       end
+
+      final_results
     end
   end
 end

data/src/stdout_reporter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative './theorem/reporter'
+
+module Theorem
+  module StringRefinements
+    refine String do
+      # colorization
+      def colorize(color_code)
+        "\e[#{color_code}m#{self}\e[0m"
+      end
+
+      def red
+        colorize(31)
+      end
+
+      def green
+        colorize(32)
+      end
+
+      def yellow
+        colorize(33)
+      end
+
+      def blue
+        colorize(34)
+      end
+
+      def pink
+        colorize(35)
+      end
+
+      def light_blue
+        colorize(36)
+      end
+    end
+  end
+
+  # Default Stdout reporter
+  module StdoutReporter
+    extend Control::Reporter
+    using StringRefinements
+
+    subscribe :on_completed_test do |test|
+      print test.failed? ? 'x'.red : '.'.green
+    end
+
+    subscribe :on_completed_suite do |results|
+      puts "\n"
+      report_summary(results)
+
+      failed_tests = results.select(&:failed?)
+
+      report_failures(failed_tests)
+    end
+
+    def report_summary(tests)
+      tests.each do |test|
+        icon = test.failed? ? '❌'.red : '✓'.green
+        puts "#{icon} #{test.full_name.blue}"
+      end
+    end
+
+    def report_failures(tests)
+      tests.each do |failure|
+        puts "Failure in #{failure.full_name}\nError: #{failure.error.message.to_s.red}\nBacktrace:\n------\n#{failure.error.backtrace.map(&:red).join("\n")}"
+      end
+    end
+  end
+end

data/src/theorem/beaker.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Theorem
+  module Control
+    # test object for around hooks
+    class FlaskTest
+      def initialize(test, ctx)
+        @test = test
+        @ctx = ctx
+      end
+
+      def run!
+        @test.run!(@ctx)
+      end
+    end
+
+    # single use container
+    class Flask
+      attr_reader :state
+
+      def initialize
+        @state = nil
+      end
+
+      def run!(test, ctx, flask_test: FlaskTest.new(test, ctx))
+        ctx.instance_exec flask_test, &@state
+        nil
+      rescue Exception => error
+        Theorem.handle_exception(error)
+
+        error
+      end
+
+      def empty?
+        @state.nil?
+      end
+
+      def prepare(&block)
+        @state = block
+      end
+    end
+
+    # reusable container
+    class Beaker
+      def initialize
+        @state = []
+      end
+
+      def run!(ctx)
+        ctx.instance_exec @state, ctx do |state, ctx|
+          state.each do |b|
+            ctx.instance_eval &b
+          end
+        end
+      end
+
+      def reverse_prepare(&block)
+        @state.unshift block
+      end
+
+      def prepare(&block)
+        @state << block
+      end
+    end
+  end
+end

data/src/theorem/completed_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Theorem
+  module Control
+    # error class
+    class CompletedTest
+      attr_reader :test, :error
+
+      def initialize(test, error = nil)
+        @test = test
+        @error = error
+      end
+
+      def full_name
+        test.full_name
+      end
+
+      def name
+        test.name
+      end
+
+      def failed?
+        !@error.nil?
+      end
+    end
+  end
+end

data/src/theorem/harness.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'hypothesis'
+require 'extended_dir'
+module Theorem
+  module Control
+    # control harness
+    module Harness
+      def self.included(mod)
+        mod.extend(ClassMethods)
+        mod.define_singleton_method :included do |inner|
+          inner.define_singleton_method :run! do |options: {}|
+            tests = inner.instance_exec options, &mod.test_loader
+            results = inner.instance_exec tests, options, &mod.run_loader
+            inner.completed_suite_subscribers.each do |subscriber|
+              subscriber.call(results)
+            end
+            exit results.any?(&:failed?) ? 1 : 0
+          end
+        end
+      end
+
+      # harness helpers
+      module ClassMethods
+        DEFAULT_LOADER = ->(options) do
+          directory = options[:directory] || '.'
+
+          ExtendedDir.require_all("./#{directory}")
+
+          registry
+        end
+
+        DEFAULT_RUNNER = ->(tests, options) do
+          tests.each_with_object([]) do |test, memo|
+            memo.concat test.run!
+          end
+        end
+
+        def load_tests(&block)
+          @on_load_tests = block
+        end
+
+        def on_run(&block)
+          @on_run = block
+        end
+
+        def run_loader
+          @on_run || DEFAULT_RUNNER
+        end
+
+        def test_loader
+          @on_load_tests || DEFAULT_LOADER
+        end
+      end
+    end
+  end
+end

data/src/theorem/hypothesis.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'completed_test'
+require_relative 'beaker'
+require_relative 'registry'
+require_relative 'test'
+
+module Theorem
+  module Control
+    # control hypothesis
+    module Hypothesis
+      def self.included(mod)
+        mod.define_singleton_method(:included) do |klass|
+          klass.define_singleton_method(:control) do
+            mod
+          end
+
+          klass.extend ClassMethods
+          klass.instance_eval do
+            @before_all ||= Beaker.new
+            @before_each ||= Beaker.new
+            @after_all ||= Beaker.new
+            @after_each ||= Beaker.new
+            @around = Flask.new
+            @tests = []
+            @completed_tests = []
+            @self = new
+          end
+          mod.add_to_registry(klass)
+        end
+
+        mod.const_set(:Beaker, Beaker)
+        mod.const_set(:Test, Test)
+        mod.const_set(:CompletedTest, CompletedTest)
+        mod.extend(Registry)
+      end
+    end
+  end
+end
+

data/src/theorem/registry.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Theorem
+  module Control
+    module Registry
+      # beaker
+      def registry
+        @registry ||= []
+      end
+
+      def add_to_registry(klass)
+        registry << klass
+      end
+
+      def on_extra_event(&block)
+        @extra_events ||= []
+        @extra_events << block
+      end
+
+      def extra_event_subscribers
+        @extra_events || []
+      end
+
+      def on_completed_test(&block)
+        @completed_tests ||= []
+        @completed_tests << block
+      end
+
+      def completed_test_subscribers
+        @completed_tests || []
+      end
+
+      def on_completed_suite(&block)
+        @completed_suites ||= []
+        @completed_suites << block
+      end
+
+      def completed_suite_subscribers
+        @completed_suites || []
+      end
+    end
+  end
+end

data/src/theorem/reporter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Theorem
+  module Control
+    # reporter mixin
+    module Reporter
+      def self.extended(mod)
+        mod.extend(mod)
+        mod.define_singleton_method :included do |root|
+          mod.subscriptions.each do |subscription, handler|
+            mod.instance_exec root, subscription, handler do |root, sub, handle|
+              root.send(sub, &handle)
+            end
+          end
+        end
+      end
+
+      def subscribe(name, &block)
+        @subscriptions ||= {}
+        @subscriptions[name] = block
+      end
+
+      def subscriptions
+        @subscriptions
+      end
+    end
+  end
+end

data/src/theorem/test.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+require_relative './beaker'
+
+module Theorem
+  module Control
+    # test new
+    class Test
+      def initialize(name, namespace, **opts, &block)
+        @name = name
+        @namespace = namespace
+        @block = block
+        @arguments = opts
+      end
+
+      attr_reader :block, :name, :arguments, :namespace
+
+      def full_name
+        "#{namespace} #{name}"
+      end
+
+      def run!(ctx)
+        ctx.instance_exec self, **arguments, &block
+      end
+    end
+
+    # module
+    module ClassMethods
+      def inherited(klass)
+        klass.include(control)
+        klass.instance_exec self do |me|
+          @parent_before_all ||= []
+          @parent_before_all << me.before_all_beaker
+
+          @parent_before_each ||= []
+          @parent_before_each << me.before_each_beaker
+
+          @parent_after_each ||= []
+          @parent_after_each.unshift me.after_each_beaker
+
+          @parent_after_all ||= []
+          @parent_after_all.unshift me.after_all_beaker
+        end
+        super
+      end
+
+      def before_all(&block)
+        @before_all.prepare(&block)
+      end
+
+      def around(&block)
+        @around.prepare(&block)
+      end
+
+      def before_each(&block)
+        @before_each.prepare(&block)
+      end
+
+      def after_each(&block)
+        @after_each.reverse_prepare(&block)
+      end
+
+      def after_all(&block)
+        @after_all.reverse_prepare(&block)
+      end
+
+      def experiments(klass, **opts, &block)
+        obj = Class.new
+        obj.include(control)
+        obj.instance_eval &block if block
+        obj.instance_exec self, klass, opts do |consumer, experiment_klass, params|
+          @tests.concat experiment_klass.tests(_experiment_namespace: consumer.to_s, **params)
+        end
+      end
+
+      def tests
+        @tests
+      end
+
+      def before_all_beaker
+        @before_all
+      end
+
+      def before_each_beaker
+        @before_each
+      end
+
+      def after_each_beaker
+        @after_each
+      end
+
+      def after_all_beaker
+        @after_all
+      end
+
+      def test(name, &block)
+        @tests << Test.new(name, to_s, &block)
+      end
+
+      def run!
+        test_case = new
+
+        before_failures = run_before_all_beakers(test_case)
+        if before_failures.any?
+          return before_failures
+        end
+
+        results = []
+        @tests.each do |test|
+          error ||= run_before_each_beakers(test_case)
+          error ||= run_test(test, test_case)
+          error ||= run_after_each_beakers(test_case)
+
+          completed_test = CompletedTest.new(test, error)
+          publish_test_completion(completed_test)
+          results << completed_test
+        end
+
+        after_failures = run_after_all_beakers(test_case)
+        if after_failures.any?
+          return after_failures
+        end
+
+        results
+      end
+
+      private
+
+      def run_test(test, test_case)
+        if @around.empty?
+          begin
+            test.run!(test_case)
+            nil
+          rescue Exception => error
+            Theorem.handle_exception(error)
+
+            error
+          end
+        else
+          @around.run!(test, test_case)
+        end
+      end
+
+      def run_after_all_beakers(test_case)
+        @after_all.run!(test_case)
+
+        @parent_after_all&.each do |beaker|
+          beaker.run!(test_case)
+        end
+
+        []
+      rescue Exception => error
+        Theorem.handle_exception(error)
+
+        @tests.map do |test|
+          CompletedTest.new(test, error)
+        end
+      end
+
+      def run_after_each_beakers(test_case)
+        @after_each.run!(test_case)
+
+        @parent_after_each&.each do |beaker|
+          beaker.run!(test_case)
+        end
+        nil
+      rescue Exception => error
+        Theorem.handle_exception(error)
+
+        error
+      end
+
+      def run_before_each_beakers(test_case)
+        @parent_before_each&.each do |beaker|
+          beaker.run!(test_case)
+        end
+        @before_each.run!(test_case)
+        nil
+      rescue Exception => error
+        Theorem.handle_exception(error)
+
+        error
+      end
+
+      def run_before_all_beakers(test_case)
+        @parent_before_all&.each do |beaker|
+          beaker.run!(test_case)
+        end
+        @before_all.run!(test_case)
+        []
+      rescue Exception => error
+        Theorem.handle_exception(error)
+
+        @tests.map do |test|
+          CompletedTest.new(test, error)
+        end
+      end
+
+      def publish_test_completion(completed_test)
+        control.completed_test_subscribers.each do |subscriber|
+          subscriber.call(completed_test)
+        end
+      end
+
+    end
+  end
+end

data/src/theorem.rb

@@ -0,0 +1,61 @@
+require_relative 'theorem/hypothesis'
+require_relative 'harness'
+require_relative 'experiment'
+require_relative 'stdout_reporter'
+require 'json'
+
+module Theorem
+  # RSpec subclasses Exception, so the only way to catch them without a dependency is to catch Exception
+  def self.custom_exceptions
+    errors = []
+    if defined? RSpec::Expectations
+      errors.concat [RSpec::Expectations::ExpectationNotMetError, RSpec::Expectations::MultipleExpectationsNotMetError]
+    end
+    errors
+  end
+
+  def self.handle_exception(error)
+    unless error.is_a?(StandardError) || custom_exceptions.include?(error.class)
+      raise error
+    end
+  end
+
+  def self.run!(options)
+    options[:require].each do |file|
+      require file
+    end
+
+    raise StandardError, "Unknown Module: #{options[:module]}" unless defined? Object.const_get(options[:module])
+    raise StandardError, "Unknown Harness: #{options[:harness]}" unless defined? Object.const_get(options[:harness])
+
+    mod = Object.const_get(options[:module])
+    harness = Object.const_get options[:harness]
+    mod.include harness
+
+    options[:publisher].each do |publisher|
+      if defined? Object.const_get(publisher)
+        mod.include Object.const_get(publisher)
+      else
+        raise StandardError, "Unknown Publisher: #{publisher}"
+      end
+    end
+
+    mod.run!(options: options)
+  end
+
+  module JsonReporter
+    extend Control::Reporter
+
+    subscribe :on_completed_suite do |results|
+      results = results.map do |result|
+        { name: result.full_name, failed: result.failed? }
+      end
+      puts results.to_json
+      puts "\n\n"
+    end
+  end
+
+  module Hypothesis
+    include Control::Hypothesis
+  end
+end

metadata

@@ -1,45 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: theorem
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Sean Gregory
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-05 00:00:00.000000000 Z
+date: 2022-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: extended_dir
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
-  name: rbs
+  name: slop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 4.9.2
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.9.2
 - !ruby/object:Gem::Dependency
-  name: rspec-expectations
+  name: rbs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rspec-expectations
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: watir
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: simple. testing. ah.
+description: simple and extensible test library toolkit
 email: sean.christopher.gregory@gmail.com
 executables:
 - theorize
@@ -88,17 +88,26 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/theorize
+- src/experiment.rb
 - src/harness.rb
-- src/hypothesis.rb
+- src/stdout_reporter.rb
+- src/theorem.rb
+- src/theorem/beaker.rb
+- src/theorem/completed_test.rb
+- src/theorem/harness.rb
+- src/theorem/hypothesis.rb
+- src/theorem/registry.rb
+- src/theorem/reporter.rb
+- src/theorem/test.rb
 homepage: https://rubygems.org/gems/theorem
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/skinnyjames/theorem
+  source_code_uri: https://gitlab.com/skinnyjames/theorem
 post_install_message:
 rdoc_options: []
 require_paths:
-- lib
+- src
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -113,5 +122,5 @@ requirements: []
 rubygems_version: 3.2.31
 signing_key:
 specification_version: 4
-summary: simple. testing. ah.
+summary: simple and extensible test library toolkit
 test_files: []

data/src/hypothesis.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module Theorem
-  # entrypoint
-  module Hypothesis
-    # beaker
-    def self.registry
-      @registry ||= []
-    end
-
-    def self.add_to_registry(klass)
-      registry << klass
-    end
-
-    def self.on_completed_test(&block)
-      @completed_tests ||= []
-      @completed_tests << block
-    end
-
-    def self.completed_test_subscribers
-      @completed_tests
-    end
-
-    class Beaker
-      def initialize
-        @state = []
-      end
-
-      def run!(ctx)
-        ctx.instance_exec @state, ctx do |state, ctx|
-          state.each do |b|
-            ctx.instance_eval &b
-          end
-        end
-      end
-
-      def prepare(&block)
-        @state << block
-      end
-    end
-
-    # error class
-    class CompletedTest
-      attr_reader :name, :error
-
-      def initialize(name, error = nil)
-        @name = name
-        @error = error
-      end
-
-      def failed?
-        !@error.nil?
-      end
-    end
-
-
-    # test
-    class Test
-      def initialize(name, beaker, &block)
-        @name = name
-        @block = block
-      end
-
-      attr_reader :block, :name
-
-      def run!(ctx)
-        ctx.instance_exec self, &block
-        nil
-      rescue Exception => ex
-        ex
-      end
-    end
-
-    def self.included(klass)
-      klass.extend ClassMethods
-      klass.instance_eval do
-        @before_all ||= Beaker.new
-        @tests = []
-        @completed_tests = []
-        @self = new
-      end
-      Hypothesis.add_to_registry(klass)
-    end
-
-    # module
-    module ClassMethods
-      def inherited(klass)
-        klass.include(Hypothesis)
-        klass.instance_exec self do |me|
-          @parent_before_all ||= []
-          @parent_before_all << me.before_all_beaker
-        end
-        super
-      end
-
-      def before_all(&block)
-        @before_all.prepare(&block)
-      end
-
-      def tests
-        @tests
-      end
-
-      def before_all_beaker
-        @before_all
-      end
-
-      def test(name, &block)
-        @tests << Test.new(name, @before_all, &block)
-      end
-
-      def run!
-        test_case = new
-        @parent_before_all&.each do |beaker|
-          beaker.run!(test_case)
-        end
-        @before_all.run!(test_case)
-        results = []
-        @tests.each do |test|
-          error = test.run!(test_case)
-          completed_test = CompletedTest.new(test.name, error)
-          publish_test_completion(completed_test)
-          results << completed_test
-        end
-        results
-      end
-
-      private
-
-      def publish_test_completion(completed_test)
-        Hypothesis.completed_test_subscribers.each do |subscriber|
-          subscriber.call(completed_test)
-        end
-      end
-    end
-  end
-end