theorem 0.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2707643c05984ddc7bb49ef7f536fad90dc70ddc7fa058ec031f3945df8e4188
-  data.tar.gz: 173b64d78b6de42218ebb90714c651a459e1ef377492840985ae8f5c0ae94a7f
+  metadata.gz: 561cfd58d73936664ce10aad722bab0fc21d97a28b421a5cc0e154bbf8f14bfa
+  data.tar.gz: 9e392733f121689bb139d908730ad2e7008f263e713d5193ede30d31f2309612
 SHA512:
-  metadata.gz: e1f9df341383f804e7437a2193e2c9cd6978861d8dd3351533b7f14f059e3fd8e941e865c455325edcfa724da490549af329fbf5cd7fdd460333d1105fefeccc
-  data.tar.gz: c9fd46000ef01e28b7f63f4c7512f599732004f129938085585b3725b8bf0abbea88961fea7048bdb5d8753dffb52b2228c4c0dacc24983668e2f3fdd2293193
+  metadata.gz: 7980418d3772ed5c314893f44cec5cd3cc166d3cf4e193580a0f1c65484e7020119c32db80ebba07e2a53e880e9f3ad5d83e45d6910dd3b3a08561642071abba
+  data.tar.gz: 25e8132963cab65e4d5822e15c1aa3dc5a8f28f225330a06f9a08bcff8d64a273bcdc86ed42035429e0bd1ac8e79676e0677061d898ba7ad460c781c6e16d7a4

data/bin/theorize

@@ -1,7 +1,21 @@
 #!/usr/bin/ruby
 
-require_relative '../src/harness'
+require 'slop'
+require_relative '../src/theorem'
 
-path = 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.array '-i', '--include', 'tags to specify what tests should be included (default: wont filter)', default: []
+  o.array '-e', '--exclude', 'tags the specify what tests should be excluded (default: wont filter)', default: []
+  o.string '--meta', 'string of metadata to pass to the harness', default: ''
+  o.on '--help' do
+    puts o
+    exit
+  end
+end
 
-Theorem::Hypothesis::Harness.run! path
+Theorem.run! opts.to_h

data/src/experiment.rb

@@ -9,9 +9,9 @@ module Theorem
         @tests << { name: name, block: block }
       end
 
-      def tests(**opts)
+      def tests(_experiment_namespace: to_s, **opts)
         @tests.map do |hash|
-          Control::Test.new(hash[:name], to_s, **opts, &hash[:block])
+          Control::Test.new(hash[:name], _experiment_namespace, **opts, &hash[:block])
         end
       end
     end

data/src/harness.rb

@@ -1,59 +1,41 @@
-require_relative './theorem'
-require 'extended_dir'
+# frozen_string_literal: true
 
-# module
+require_relative './theorem/harness'
+
+# harness
 module Theorem
-  # module
-  module Hypothesis
-    on_completed_test do |test|
-      print test.failed? ? 'X' : '.'
-    end
+  # default test harness
+  module Harness
+    include Control::Harness
 
-    # harness
-    class Harness
-      def self.locate_tests(dir)
-        ExtendedDir.require_all("./#{dir}")
+    load_tests do |options|
+      directory = options[:directory] || '.'
 
-        Hypothesis.registry
-      end
-
-      def self.get_test_count(test_cases)
-        test_cases.map do |test_case|
-          test_case.tests.size
-        end.inject(&:+)
-      end
+      ExtendedDir.require_all("./#{directory}")
 
-      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
+      filtered_registry(options)
+    end
+  end
 
-      def self.run!(dir)
-        test_cases = locate_tests(dir)
-        total_count = get_test_count(test_cases)
+  # module retry harness
+  module RetryHarness
+    include Control::Harness
 
-        puts "Total tests #{total_count}"
+    on_run do |tests|
+      arr_of_tests = tests.map { |test| { test: test, index: 0 } }
 
-        results = test_cases.each_with_object([]) do |test_case, memo|
-          memo.concat test_case.run!
+      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
-
-        puts "\n\nSummary\n-------"
-
-        failed_tests, passed_tests = results.partition(&:failed?)
-
-        report_passes(passed_tests)
-        report_failures(failed_tests)
-
-        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

@@ -54,6 +54,10 @@ module Theorem
         end
       end
 
+      def reverse_prepare(&block)
+        @state.unshift block
+      end
+
       def prepare(&block)
         @state << block
       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

@@ -19,6 +19,8 @@ module Theorem
           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 = []

data/src/theorem/registry.rb

@@ -8,10 +8,35 @@ module Theorem
         @registry ||= []
       end
 
+      def filtered_registry(options)
+        registry.each do |test_class|
+          if options[:include]&.any?
+            test_class.tests.select! do |test|
+              test.metadata[:tags]&.intersection(options[:include])&.any?
+            end
+          end
+
+          next unless options[:exclude]&.any?
+
+          test_class.tests.reject! do |test|
+            test.metadata[:tags]&.intersection(options[:include])&.any?
+          end
+        end
+      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
@@ -20,6 +45,15 @@ module Theorem
       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

@@ -5,14 +5,15 @@ module Theorem
   module Control
     # test new
     class Test
-      def initialize(name, namespace, **opts, &block)
+      def initialize(name, namespace, arguments: {}, **metadata, &block)
         @name = name
         @namespace = namespace
         @block = block
-        @arguments = opts
+        @arguments = arguments
+        @metadata = metadata
       end
 
-      attr_reader :block, :name, :arguments, :namespace
+      attr_reader :block, :name, :arguments, :namespace, :metadata
 
       def full_name
         "#{namespace} #{name}"
@@ -33,6 +34,12 @@ module Theorem
 
           @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
@@ -49,12 +56,20 @@ module Theorem
         @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 klass, opts do |experiment_klass, params|
-          @tests.concat experiment_klass.tests(**params)
+        obj.instance_exec self, klass, opts do |consumer, experiment_klass, params|
+          @tests.concat experiment_klass.tests(_experiment_namespace: consumer.to_s, arguments: params)
         end
       end
 
@@ -70,8 +85,16 @@ module Theorem
         @before_each
       end
 
-      def test(name, &block)
-        @tests << Test.new(name, to_s, &block)
+      def after_each_beaker
+        @after_each
+      end
+
+      def after_all_beaker
+        @after_all
+      end
+
+      def test(name, **hargs, &block)
+        @tests << Test.new(name, to_s, **hargs, &block)
       end
 
       def run!
@@ -84,15 +107,20 @@ module Theorem
 
         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)
+          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
 
@@ -113,11 +141,13 @@ module Theorem
         end
       end
 
-      def run_before_each_beakers(test_case)
-        @parent_before_each&.each do |beaker|
+      def run_after_all_beakers(test_case)
+        @after_all.run!(test_case)
+
+        @parent_after_all&.each do |beaker|
           beaker.run!(test_case)
         end
-        @before_each.run!(test_case)
+
         []
       rescue Exception => error
         Theorem.handle_exception(error)
@@ -127,6 +157,31 @@ module Theorem
         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)

data/src/theorem.rb

@@ -1,5 +1,10 @@
 require_relative 'theorem/hypothesis'
+require_relative 'harness'
 require_relative 'experiment'
+require_relative 'stdout_reporter'
+
+require_relative 'theorem/harness'
+require 'json'
 
 module Theorem
   # RSpec subclasses Exception, so the only way to catch them without a dependency is to catch Exception
@@ -17,6 +22,41 @@ module Theorem
     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

metadata

@@ -1,45 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: theorem
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Sean Gregory
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-08 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
@@ -90,21 +90,24 @@ files:
 - bin/theorize
 - src/experiment.rb
 - src/harness.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:
   - - ">="
@@ -119,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: []