theorem 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82f4b3d0f32345396cdbc66fc1d28d00d014f3576c8cf36e18eb355913fd34cd
-  data.tar.gz: ac2241928677901a46a9e12fb980e7a787f9e43ede2c7bf862a0bb3277fe6527
+  metadata.gz: 2707643c05984ddc7bb49ef7f536fad90dc70ddc7fa058ec031f3945df8e4188
+  data.tar.gz: 173b64d78b6de42218ebb90714c651a459e1ef377492840985ae8f5c0ae94a7f
 SHA512:
-  metadata.gz: 2233e6daab124321a5f83dda68b09b8159f1561afb5b9cb8c2f1b626170dce551ed1a833164fc2e58cc5a02a86f216b0be95057b4f8aee6b2c986c3928c10837
-  data.tar.gz: 7b4432d63c2a4bdc6c18875b7fdecc27cb14412fcdbaf8d3867fd31863ff8173faa21d2e1b37db65848af72571e7656ebf5ce0a31ed8d21697f2412a9f052976
+  metadata.gz: e1f9df341383f804e7437a2193e2c9cd6978861d8dd3351533b7f14f059e3fd8e941e865c455325edcfa724da490549af329fbf5cd7fdd460333d1105fefeccc
+  data.tar.gz: c9fd46000ef01e28b7f63f4c7512f599732004f129938085585b3725b8bf0abbea88961fea7048bdb5d8753dffb52b2228c4c0dacc24983668e2f3fdd2293193

data/bin/theorize

@@ -2,4 +2,6 @@
 
 require_relative '../src/harness'
 
-Theorem::Hypothesis::Harness.run! ARGV[0] || '.'
+path = ARGV[0] || '.'
+
+Theorem::Hypothesis::Harness.run! path

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(**opts)
+        @tests.map do |hash|
+          Control::Test.new(hash[:name], to_s, **opts, &hash[:block])
+        end
+      end
+    end
+  end
+end

data/src/harness.rb

@@ -1,8 +1,9 @@
-require_relative './hypothesis'
+require_relative './theorem'
 require 'extended_dir'
 
 # module
 module Theorem
+  # module
   module Hypothesis
     on_completed_test do |test|
       print test.failed? ? 'X' : '.'
@@ -16,22 +17,40 @@ module Theorem
         Hypothesis.registry
       end
 
-      def self.run!(dir)
-        test_cases = locate_tests(dir)
-        total_count = test_cases.map do |test_case|
+      def self.get_test_count(test_cases)
+        test_cases.map do |test_case|
           test_case.tests.size
         end.inject(&:+)
+      end
+
+      def self.report_failures(failed_tests)
+        failed_tests.each do |failure|
+          puts "❌ Failure in #{failure.full_name}\nError: #{failure.error}\nBacktrace:\n------\n#{failure.error.backtrace.join("\n")}"
+        end
+      end
+
+      def self.report_passes(passing_tests)
+        passing_tests.each do |pass|
+          puts "✓ #{pass.full_name}"
+        end
+      end
+
+      def self.run!(dir)
+        test_cases = locate_tests(dir)
+        total_count = get_test_count(test_cases)
 
         puts "Total tests #{total_count}"
 
-        results = test_cases.map(&:run!).flatten
+        results = test_cases.each_with_object([]) do |test_case, memo|
+          memo.concat test_case.run!
+        end
 
         puts "\n\nSummary\n-------"
 
-        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")}"
-        end
+        failed_tests, passed_tests = results.partition(&:failed?)
+
+        report_passes(passed_tests)
+        report_failures(failed_tests)
 
         exit failed_tests.any? ? 1 : 0
       end

data/src/theorem/beaker.rb

@@ -0,0 +1,62 @@
+# 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 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/hypothesis.rb

@@ -0,0 +1,38 @@
+# 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
+            @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,25 @@
+# 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_completed_test(&block)
+        @completed_tests ||= []
+        @completed_tests << block
+      end
+
+      def completed_test_subscribers
+        @completed_tests || []
+      end
+    end
+  end
+end

data/src/theorem/test.rb

@@ -0,0 +1,152 @@
+# 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
+        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 experiments(klass, **opts, &block)
+        obj = Class.new
+        obj.include(control)
+        obj.instance_eval &block if block
+        obj.instance_exec klass, opts do |experiment_klass, params|
+          @tests.concat experiment_klass.tests(**params)
+        end
+      end
+
+      def tests
+        @tests
+      end
+
+      def before_all_beaker
+        @before_all
+      end
+
+      def before_each_beaker
+        @before_each
+      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|
+          before_each_failures = run_before_each_beakers(test_case)
+          return before_each_failures if before_each_failures.any?
+
+          error = run_test(test, test_case)
+
+          completed_test = CompletedTest.new(test, error)
+          publish_test_completion(completed_test)
+          results << completed_test
+        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_before_each_beakers(test_case)
+        @parent_before_each&.each do |beaker|
+          beaker.run!(test_case)
+        end
+        @before_each.run!(test_case)
+        []
+      rescue Exception => error
+        Theorem.handle_exception(error)
+
+        @tests.map do |test|
+          CompletedTest.new(test, error)
+        end
+      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,23 @@
+require_relative 'theorem/hypothesis'
+require_relative 'experiment'
+
+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
+
+  module Hypothesis
+    include Control::Hypothesis
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: theorem
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Sean Gregory
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-05 00:00:00.000000000 Z
+date: 2022-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: extended_dir
@@ -88,8 +88,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/theorize
+- src/experiment.rb
 - src/harness.rb
-- src/hypothesis.rb
+- src/theorem.rb
+- src/theorem/beaker.rb
+- src/theorem/completed_test.rb
+- src/theorem/hypothesis.rb
+- src/theorem/registry.rb
+- src/theorem/test.rb
 homepage: https://rubygems.org/gems/theorem
 licenses:
 - MIT

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