test_bench-run 2.1.3.1 → 3.0.0.0.pre.1

data/lib/test_bench/run/run.rb

@@ -1,127 +1,125 @@
 module TestBench
   class Run
-    Error = Class.new(RuntimeError)
-
-    include Events
+    def summary
+      @summary ||= Summary::Substitute.build
+    end
+    attr_writer :summary
 
-    def telemetry
-      @telemetry ||= Telemetry::Substitute.build
+    def select_files
+      @select_files ||= SelectFiles::Substitute.build
     end
-    attr_writer :telemetry
+    attr_writer :select_files
 
     def session
       @session ||= Session::Substitute.build
     end
     attr_writer :session
 
-    def get_files
-      @get_files ||= GetFiles::Substitute.build
+    def print_summary
+      @print_summary.nil? ?
+        @print_summary = true :
+        @print_summary
     end
-    attr_writer :get_files
+    attr_writer :print_summary
+    alias :print_summary? :print_summary
 
-    def executor
-      @executor ||= Executor::Substitute.build
+    def abort_on_failure
+      @abort_on_failure.nil? ?
+        @abort_on_failure = false :
+        @abort_on_failure
     end
-    attr_writer :executor
-
-    def random
-      @random ||= Random::Substitute.build
-    end
-    attr_writer :random
+    attr_writer :abort_on_failure
+    alias :abort_on_failure? :abort_on_failure
 
     def path_sequence
       @path_sequence ||= 0
     end
     attr_writer :path_sequence
 
-    def self.build(exclude: nil, session: nil)
+    def self.build(exclude: nil, print_summary: nil, abort_on_failure: nil, session: nil)
+      if print_summary.nil?
+        print_summary = Defaults.print_summary
+      end
+
+      if abort_on_failure.nil?
+        abort_on_failure = Defaults.abort_on_failure
+      end
+
       instance = new
 
-      GetFiles.configure(instance, exclude:)
+      instance.print_summary = print_summary
+      instance.abort_on_failure = abort_on_failure
+
+      Session.configure(instance, session:)
 
-      Executor::Serial.configure(instance)
+      Summary.configure(instance)
 
-      Random.configure(instance)
+      SelectFiles.configure(instance, exclude_patterns: exclude)
 
-      if session.nil?
-        session = Session.build do |telemetry|
-          Output::File.register(telemetry)
-          Output::Summary::Error.register(telemetry)
-          Output::Summary.register(telemetry)
-        end
-      end
+      session = instance.session
 
-      instance.telemetry = session.telemetry
+      Output.register_telemetry_sink(session)
 
-      Session.configure(instance, session:)
+      summary = instance.summary
+      session.register_telemetry_sink(summary)
 
       instance
     end
 
-    def self.call(path, session_store: nil, exclude: nil)
-      session_store ||= Session::Store.instance
-
-      instance = build(exclude:)
+    def self.configure(receiver, attr_name: nil)
+      attr_name ||= :run
 
-      session_store.reset(instance.session)
+      session = establish_session
 
-      instance.(path)
+      instance = build(session:)
+      receiver.public_send(:"#{attr_name}=", instance)
     end
 
-    def self.configure(receiver, exclude: nil, session: nil, attr_name: nil)
-      attr_name ||= :run
+    def self.call(path, exclude: nil)
+      session = establish_session
 
       instance = build(exclude:, session:)
-      receiver.public_send(:"#{attr_name}=", instance)
-    end
 
-    def call(path)
-      run do
-        path(path)
+      instance.() do
+        instance << path
       end
     end
 
-    def run(&block)
-      if ran?
-        raise Error, "Already ran"
-      end
-
-      telemetry.record(Started.build(random.seed))
-
-      executor.start
-
-      if not block.nil?
-        block.(self)
+    def self.establish_session
+      session = Session.build
+      Session.establish(session)
+      session
+    end
 
-        if not ran?
-          raise Error, "No paths were supplied"
-        end
-      end
+    def call(&block)
+      block.(self)
 
-      executor.finish
+      session.isolate.stop
 
-      if session.passed?
-        result = true
-      elsif session.failed?
-        result = false
+      if print_summary?
+        summary.print
       end
 
-      telemetry.record(Finished.build(random.seed, result))
-      result
+      result = session.result
+      Session::Result.resolve(result)
     end
-    alias :! :run
 
     def path(path)
       self.path_sequence += 1
 
-      get_files.(path) do |file|
-        executor.execute(file)
-      end
+      select_files.(path) do |file_path|
+        if abort_on_failure?
+          case session.result
+          when Session::Result.aborted, Session::Result.failed
+            next
+          end
+        end
 
-    rescue GetFiles::FileError
-      warn "#{path}: No such file or directory"
+        session.execute(file_path)
+      end
 
-      session.record_failure
+    rescue SelectFiles::PathNotFoundError
+      session.execute(path)
     end
     alias :<< :path
 
@@ -129,27 +127,17 @@ module TestBench
       path_sequence > 0
     end
 
-    module Substitute
-      def self.build
-        Run.build
-      end
+    module Defaults
+      def self.abort_on_failure
+        env_abort_on_failure = ENV.fetch('TEST_BENCH_ABORT_ON_FAILURE', 'off')
 
-      class Run < Run
-        def self.build
-          new
-        end
+        env_abort_on_failure == 'on'
+      end
 
-        def path?(path)
-          get_files.path?(path)
-        end
+      def self.print_summary
+        env_print_summary = ENV.fetch('TEST_BENCH_OUTPUT_SUMMARY', 'on')
 
-        def set_result(result)
-          if result
-            session.record_assertion
-          else
-            session.record_failure
-          end
-        end
+        env_print_summary == 'on'
       end
     end
   end

data/lib/test_bench/run/{get_files → select_files}/substitute.rb

@@ -1,15 +1,12 @@
 module TestBench
   class Run
-    class GetFiles
+    class SelectFiles
       module Substitute
         def self.build
-          GetFiles.new
+          SelectFiles.new
         end
 
-        class GetFiles
-          attr_accessor :file_error
-          def file_error? = !!file_error
-
+        class SelectFiles
           def files
             @files ||= []
           end
@@ -20,18 +17,18 @@ module TestBench
             @paths ||= []
           end
 
-          def file_error!
-            self.file_error = true
+          attr_accessor :raise_path_not_found_error
+
+          def raise_path_not_found_error!
+            self.raise_path_not_found_error = true
           end
 
-          def call(path, *paths, &block)
-            [path, *paths].each do |path|
-              self.paths << path
+          def call(path, &block)
+            if raise_path_not_found_error
+              raise PathNotFoundError
             end
 
-            if file_error?
-              raise FileError
-            end
+            self.paths << path
 
             files.each(&block)
           end

data/lib/test_bench/run/select_files.rb

@@ -0,0 +1,68 @@
+module TestBench
+  class Run
+    class SelectFiles
+      PathNotFoundError = Class.new(RuntimeError)
+
+      def exclude_patterns
+        @exclude_patterns ||= []
+      end
+      attr_writer :exclude_patterns
+
+      attr_accessor :apex_directory
+
+      def self.build(exclude_patterns: nil)
+        exclude_patterns ||= Defaults.exclude_file_patterns
+
+        exclude_patterns = Array(exclude_patterns)
+
+        instance = new
+        instance.exclude_patterns = exclude_patterns
+        instance
+      end
+
+      def self.configure(receiver, exclude_patterns: nil, attr_name: nil)
+        attr_name ||= :select_files
+
+        instance = build(exclude_patterns:)
+        receiver.public_send(:"#{attr_name}=", instance)
+      end
+
+      def call(path, &block)
+        full_path = ::File.expand_path(path, apex_directory)
+        if not ::File.exist?(full_path)
+          raise PathNotFoundError, "No such file or directory - #{full_path}"
+        end
+
+        extension = ::File.extname(path)
+
+        if extension.empty?
+          directory_path = path
+          glob_pattern = ::File.join(directory_path, '**', '*.rb')
+        else
+          file_path = path
+          glob_pattern = file_path
+        end
+
+        Dir.glob(glob_pattern, base: apex_directory) do |file|
+          excluded = exclude_patterns.any? do |exclude_pattern|
+            ::File.fnmatch?(exclude_pattern, file, ::File::FNM_EXTGLOB)
+          end
+
+          if excluded
+            next
+          end
+
+          block.(file)
+        end
+      end
+
+      module Defaults
+        def self.exclude_file_patterns
+          env_exclude_file_pattern = ENV.fetch('TEST_BENCH_EXCLUDE_FILE_PATTERN', '*_init.rb')
+
+          env_exclude_file_pattern.split(':')
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/run/substitute.rb

@@ -0,0 +1,40 @@
+module TestBench
+  class Run
+    module Substitute
+      def self.build
+        Run.new
+      end
+
+      class Run
+        attr_accessor :result
+        alias :set_result :result=
+
+        attr_accessor :ran
+        def ran?
+          ran ? true : false
+        end
+
+        def paths
+          @paths ||= []
+        end
+
+        def call(&block)
+          block.(self)
+
+          result
+        end
+
+        def path(path)
+          self.ran = true
+
+          paths << path
+        end
+        alias :<< :path
+
+        def path?(path)
+          paths.include?(path)
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/run/summary/substitute.rb

@@ -0,0 +1,17 @@
+module TestBench
+  class Run
+    class Summary
+      module Substitute
+        def self.build
+          Summary.new
+        end
+
+        class Summary < Summary
+          def printed?(...)
+            writer.written?(...)
+          end
+        end
+      end
+    end
+  end
+end