test_bench-session 2.1.3.2 → 3.0.0.0.pre.2

data/lib/test_bench/session/session.rb

@@ -1,260 +1,233 @@
 module TestBench
   class Session
     Failure = Class.new(RuntimeError)
-    Abort = Class.new(Failure)
+
+    ExecutionBreak = Object.new
 
     def telemetry
-      @telemetry ||= TestBench::Telemetry::Substitute.build
+      @telemetry ||= Telemetry::Substitute.build
     end
     attr_writer :telemetry
 
-    def failure_sequence
-      @failure_sequence ||= 0
+    def format_backtrace
+      @format_backtrace ||= Exception::FormatBacktrace::Substitute.build
+    end
+    attr_writer :format_backtrace
+
+    def isolate
+      @isolate ||= Isolate::Substitute.build
+    end
+    attr_writer :isolate
+
+    def status
+      @status ||= Status.initial
     end
-    attr_writer :failure_sequence
+    attr_writer :status
+
+    def trace
+      @trace ||= Trace.new
+    end
+    attr_writer :trace
 
     def assertion_sequence
       @assertion_sequence ||= 0
     end
     attr_writer :assertion_sequence
 
-    def skip_sequence
-      @skip_sequence ||= 0
-    end
-    attr_writer :skip_sequence
-
-    def self.build(&block)
+    def self.build
       instance = new
 
       Telemetry.configure(instance)
-
-      if not block.nil?
-        block.(instance.telemetry)
-      end
+      Exception::FormatBacktrace.configure(instance)
+      Isolate.configure(instance)
 
       instance
     end
 
-    def self.configure(receiver, session: nil, attr_name: nil, &block)
-      session ||= Store.fetch
-      attr_name ||= :session
-
-      instance = session
-      receiver.public_send(:"#{attr_name}=", instance)
+    def self.instance
+      @instance ||= build
     end
 
-    def inspect
-      text = self.to_s
-
-      instance_variables = self.instance_variables - [:@telemetry]
+    def self.configure(receiver, session: nil, attr_name: nil)
+      session ||= instance
+      attr_name ||= :session
 
-      instance_variables.each_with_index do |name, index|
-        ivar_text = String.new
+      receiver.public_send(:"#{attr_name}=", session)
+    end
 
-        if index > 0
-          ivar_text << ','
-        end
+    def self.establish(session)
+      @instance = session
+    end
 
-        value = instance_variable_get(name)
-        value = value.inspect
+    def self.register_telemetry_sink(telemetry_sink)
+      instance.register_telemetry_sink(telemetry_sink)
+    end
 
-        ivar_text << " #{name}=#{value}"
+    def assert(value, failure_message)
+      self.assertion_sequence += 1
 
-        text.insert(-2, ivar_text)
+      if not value
+        raise Failure, failure_message
       end
-
-      text
     end
 
-    def passed?
-      if failed?
-        false
-      elsif require_passing_test?
-        asserted? && !skipped?
-      else
-        true
-      end
+    def comment(text, disposition=nil)
+      record_event(Events::Commented.build(text, disposition))
     end
 
-    def require_passing_test?
-      Defaults.require_passing_tests
+    def detail(text, disposition=nil)
+      record_event(Events::Detailed.build(text, disposition))
     end
 
-    def fixture(name, &block)
-      original_failure_sequence = failure_sequence
-
-      record_event(Events::FixtureStarted.new(name))
+    def test(title=nil, &block)
+      record_event(Events::TestStarted.build(title))
 
-      begin
-        block.()
+      pending_test_finished_event = Events::TestFinished.build(title)
 
-      rescue Failure
+      evaluate(pending_test_finished_event) do
+        previous_sequence = self.assertion_sequence
 
-      ensure
-        result = !failed?(original_failure_sequence)
+        block.()
 
-        record_event(Events::FixtureFinished.new(name, result))
+        if self.assertion_sequence == previous_sequence
+          raise Failure, "Test didn't perform an assertion"
+        end
       end
-
-      result
     end
 
-    def detail(text, quote, heading=nil)
-      record_event(Events::Detailed.new(text, quote, heading))
-    end
+    def context(title=nil, &block)
+      record_event(Events::ContextStarted.build(title))
+
+      pending_context_finished_event = Events::ContextFinished.build(title)
 
-    def comment(text, quote, heading=nil)
-      record_event(Events::Commented.new(text, quote, heading))
+      evaluate(pending_context_finished_event, &block)
     end
 
-    def context!(...)
-      if context(...) == false
-        message = Session.abort_message
-        raise Abort, message
-      end
+    def skip(message=nil)
+      record_event(Events::Skipped.build(message))
     end
 
-    def context(title=nil, &block)
-      if block.nil?
-        record_skip
-        record_event(Events::ContextSkipped.new(title))
+    def execute(file_path)
+      if file_not_found?(file_path)
+        record_event(Events::FileNotFound.build(file_path))
         return
       end
 
-      original_failure_sequence = failure_sequence
+      record_event(Events::FileQueued.build(file_path))
 
-      record_event(Events::ContextStarted.new(title))
+      pended_event = Events::FileExecuted.build(file_path, result)
 
-      begin
-        block.()
-
-      rescue Failure
-
-      ensure
-        result = !failed?(original_failure_sequence)
-
-        record_event(Events::ContextFinished.new(title, result))
+      evaluate(pended_event) do
+        isolate.(file_path) do |event_data|
+          record_event(event_data)
+        end
       end
+    end
 
-      result
+    def file_not_found?(file_path)
+      !File.exist?(file_path)
     end
 
-    def test!(...)
-      if test(...) == false
-        message = Session.abort_message
-        raise Abort, message
-      end
+    def register_telemetry_sink(telemetry_sink)
+      telemetry.register(telemetry_sink)
     end
 
-    def test(title=nil, &block)
-      if block.nil?
-        record_skip
-        record_event(Events::TestSkipped.new(title))
-        return
+    def inspect(raw: nil)
+      if raw
+        return super()
       end
 
-      original_failure_sequence = failure_sequence
-      original_assertion_sequence = assertion_sequence
-
-      record_event(Events::TestStarted.new(title))
-
-      begin
-        block.()
+      telemetry_placeholder = Struct.new(:inspect).new("(not inspected)")
 
-        result = !failed?(original_failure_sequence)
+      original_telemetry = self.telemetry
 
-        if result
-          if not asserted?(original_assertion_sequence)
-            failure_message = Session.no_assertion_message
-            fail(failure_message)
-          end
-        end
+      self.telemetry = telemetry_placeholder
 
-      rescue Failure
-        result = false
+      begin
+        super()
 
       ensure
-        record_event(Events::TestFinished.new(title, result))
+        self.telemetry = original_telemetry
       end
-
-      result
     end
 
-    def assert(result)
-      failure_message = Session.assertion_failure_message
+    def update(event_or_event_data)
+      case event_or_event_data
+      in Telemetry::Event => event
 
-      record_assertion
+      in Telemetry::EventData => event_data
+        event_type = event_data.type
+        event_class = Events.const_get(event_type, false)
 
-      if result == false
-        fail(failure_message)
+        event = Telemetry::Event::Import.(event_data, event_class)
       end
-    end
 
-    def fail(message=nil)
-      message ||= self.class.default_failure_message
+      case event
+      when Events::ContextStarted, Events::TestStarted
+        title = event.title
 
-      record_failure
+        if not title.nil?
+          trace.push(title)
+        end
 
-      record_event(Events::Failed.new(message))
+      when Events::Commented, Events::Detailed
+        trace.push(event.text)
+      end
 
-      raise Failure, message
-    end
+      telemetry.record(event)
 
-    def asserted?(compare_sequence=nil)
-      compare_sequence ||= 0
+      status.update(event)
 
-      compare_sequence != assertion_sequence
-    end
+      case event
+      when Events::Commented, Events::Detailed
+        trace.pop
 
-    def register_telemetry_sink(telemetry_sink)
-      telemetry.register(telemetry_sink)
+      when Events::ContextFinished, Events::TestFinished
+        title = event.title
+
+        if not title.nil?
+          trace.pop
+        end
+      end
     end
+    alias :record_event :update
 
-    def record_assertion
-      self.assertion_sequence += 1
+    def result(previous_status=nil)
+      status.result(previous_status)
     end
 
-    def failed?(compare_sequence=nil)
-      compare_sequence ||= 0
+    def evaluate(pending_event, &block)
+      previous_status = status.dup
 
-      compare_sequence != failure_sequence
-    end
+      catch(ExecutionBreak) do
+        block.(self)
+      end
 
-    def record_event(event)
-      telemetry.record(event)
-    end
+    rescue Failure => failure
+      message = failure.message
+      record_event(Events::Failed.build(message))
 
-    def record_failure
-      self.failure_sequence += 1
-    end
+    rescue ::Exception => exception
+      aborted_recorded = status.error_sequence > previous_status.error_sequence
 
-    def skipped?
-      skip_sequence != 0
-    end
+      if not aborted_recorded
+        location = format_backtrace.(exception)
 
-    def record_skip
-      self.skip_sequence += 1
-    end
+        message = exception.detailed_message
 
-    def self.default_failure_message
-      'Failed'
-    end
+        record_event(Events::Aborted.build(message, location))
+      end
 
-    def self.assertion_failure_message
-      "Assertion failed"
-    end
+      raise exception
 
-    def self.abort_message
-      "Abort"
-    end
+    ensure
+      result = status.result(previous_status, pending_event)
 
-    def self.no_assertion_message
-      "Test didn't perform an assertion"
-    end
+      pending_event.result = result
+      record_event(pending_event)
 
-    module Defaults
-      def self.require_passing_tests
-        ENV.fetch('TEST_BENCH_REQUIRE_PASSING_TEST', 'on') == 'on'
+      if exception.nil?
+        return result
       end
     end
   end

data/lib/test_bench/session/status.rb

@@ -0,0 +1,58 @@
+module TestBench
+  class Session
+    Status = Struct.new(:test_sequence, :failure_sequence, :error_sequence, :skip_sequence)
+
+    class Status
+      def self.initial
+        new(0, 0, 0, 0)
+      end
+
+      def result(previous_status=nil, pending_event=nil)
+        previous_status ||= Status.initial
+
+        compare_status = compare(previous_status)
+
+        if not pending_event.nil?
+          compare_status.update(pending_event)
+        end
+
+        if compare_status.error_sequence > 0
+          Result.aborted
+        elsif compare_status.failure_sequence > 0
+          Result.failed
+        elsif compare_status.skip_sequence > 0
+          Result.incomplete
+        elsif not compare_status.test_sequence > 0
+          Result.none
+        else
+          Result.passed
+        end
+      end
+
+      def update(event)
+        case event
+        when Events::TestFinished
+          self.test_sequence += 1
+        when Events::Failed
+          self.failure_sequence += 1
+        when Events::Aborted, Events::FileNotFound
+          self.error_sequence += 1
+        when Events::Skipped
+          self.skip_sequence += 1
+        end
+      end
+
+      def compare(previous_status)
+        test_sequence_difference = test_sequence - previous_status.test_sequence
+
+        failure_sequence_difference = failure_sequence - previous_status.failure_sequence
+
+        error_sequence_difference = error_sequence - previous_status.error_sequence
+
+        skip_sequence_difference = skip_sequence - previous_status.skip_sequence
+
+        Status.new(test_sequence_difference, failure_sequence_difference, error_sequence_difference, skip_sequence_difference)
+      end
+    end
+  end
+end

data/lib/test_bench/session/substitute/sink.rb

@@ -3,50 +3,35 @@ module TestBench
     module Substitute
       class Sink
         include Telemetry::Sink
-        include Events
+
+        def trace
+          @trace ||= Trace.new
+        end
+        attr_writer :trace
 
         def records
           @records ||= []
         end
         attr_writer :records
 
-        def path
-          @path ||= Path.new
-        end
-        attr_writer :path
-
-        def receive(event_data)
-          event_type = event_data.type
+        def self.build(trace=nil)
+          instance = new
 
-          case event_data.type
-          when :TestStarted, :ContextStarted
-            title, * = event_data.data
-            if not title.nil?
-              path.push(title)
-            end
-
-          when :TestFinished, :ContextFinished
-            title, * = event_data.data
-            if not title.nil?
-              path.pop(title)
-            end
+          if not trace.nil?
+            instance.trace = trace
           end
 
-          record = Record.new(event_data)
-          path.copy(record)
+          instance
+        end
 
-          case event_data.type
-          when :TestFinished, :ContextFinished
-            title, * = event_data.data
-            if not title.nil?
-              record.path.push(title)
-            end
+        def receive(event_data)
+          trace_copy = Trace.new
 
-          when :Commented, :Detailed
-            comment_text, * = event_data.data
-            record.path.push(comment_text)
+          trace.each do |entry|
+            trace_copy.push(entry)
           end
 
+          record = Record.new(event_data, trace_copy)
           records.push(record)
 
           record
@@ -62,32 +47,32 @@ module TestBench
           end
         end
 
-        def one_event?(event_class, *path_segments, **attributes)
-          event_sink = event_sink(*path_segments)
+        def one_event?(event_class, *titles, **attributes)
+          event_sink = event_sink(*titles)
           event_sink.one_event?(event_class, **attributes)
         end
 
-        def one_event(event_class, *path_segments, **attributes)
-          event_sink = event_sink(*path_segments)
+        def one_event(event_class, *titles, **attributes)
+          event_sink = event_sink(*titles)
           event_sink.one_event(event_class, **attributes)
         end
 
-        def any_event?(event_class, *path_segments, **attributes)
-          event_sink = event_sink(*path_segments)
+        def any_event?(event_class, *titles, **attributes)
+          event_sink = event_sink(*titles)
           event_sink.any_event?(event_class, **attributes)
         end
         alias :event? :any_event?
 
-        def events(event_class, *path_segments, **attributes)
-          event_sink = event_sink(*path_segments)
+        def events(event_class, *titles, **attributes)
+          event_sink = event_sink(*titles)
           event_sink.events(event_class, **attributes)
         end
 
-        def event_sink(*path_segments)
+        def event_sink(*titles)
           event_sink = Telemetry::Substitute::Sink.new
 
           records.each do |record|
-            if record.match?(path_segments)
+            if record.match?(titles)
               event_data = record.event_data
 
               event_sink.receive(event_data)
@@ -97,10 +82,10 @@ module TestBench
           event_sink
         end
 
-        Record = Struct.new(:event_data, :path) do
-          def match?(path_segments)
-            if path_segments.any?
-              path.match?(*path_segments)
+        Record = Struct.new(:event_data, :trace) do
+          def match?(titles)
+            if titles.any?
+              trace.match?(*titles)
             else
               true
             end