test_bench-session 2.0.0.0 → 2.1.0.0

data/lib/test_bench/session/output.rb

@@ -0,0 +1,375 @@
+module TestBench
+  class Session
+    class Output
+      include TestBench::Output
+      include Events
+
+      def pending_writer
+        @pending_writer ||= Writer::Substitute.build
+      end
+      attr_writer :pending_writer
+
+      def passing_writer
+        @passing_writer ||= Writer::Substitute.build
+      end
+      attr_writer :passing_writer
+
+      def failing_writer
+        @failing_writer ||= Writer::Substitute.build
+      end
+      attr_writer :failing_writer
+
+      def failures
+        @failures ||= 0
+      end
+      attr_writer :failures
+
+      def mode
+        @mode ||= Mode.initial
+      end
+      attr_writer :mode
+
+      def branch_count
+        @branch_count ||= 0
+      end
+      attr_writer :branch_count
+
+      def detail_policy
+        @detail_policy ||= Detail.default
+      end
+      alias :detail :detail_policy
+      attr_writer :detail_policy
+
+      def configure(detail: nil, **arguments)
+        if not detail.nil?
+          self.detail_policy = detail
+        end
+
+        Writer.configure(self, **arguments, attr_name: :pending_writer)
+      end
+
+      def receive(event_data)
+        case event_data.type
+        when ContextStarted.event_type, TestStarted.event_type
+          branch
+        end
+
+        if initial?
+          handle(event_data)
+
+        else
+          self.mode = Mode.failing
+          handle(event_data)
+
+          self.mode = Mode.passing
+          handle(event_data)
+
+          self.mode = Mode.pending
+          handle(event_data)
+        end
+
+        case event_data.type
+        when ContextFinished.event_type, TestFinished.event_type
+          _title, result = event_data.data
+          merge(result)
+        end
+      end
+
+      handle ContextStarted do |context_started|
+        title = context_started.title
+
+        if not title.nil?
+          writer.
+            indent.
+            style(:green).
+            puts(title)
+
+          writer.indent!
+
+          if branch_count == 1
+            self.failures = 0
+          end
+        end
+      end
+
+      handle ContextFinished do |context_finished|
+        title = context_finished.title
+
+        if not title.nil?
+          writer.deindent!
+
+          if branch_count == 1
+            writer.puts
+
+            if failing? && failures > 0
+              writer.
+                style(:bold, :red).
+                puts("Failure#{'s' if not failures == 1}: #{failures}")
+
+              writer.puts
+            end
+          end
+        end
+      end
+
+      handle ContextSkipped do |context_skipped|
+        title = context_skipped.title
+
+        if not writer.styling?
+          title = "#{title} (skipped)"
+        end
+
+        writer.
+          indent.
+          style(:yellow).
+          puts(title)
+      end
+
+      handle TestStarted do |test_started|
+        title = test_started.title
+
+        if title.nil?
+          if passing?
+            return
+          else
+            title = 'Test'
+          end
+        end
+
+        writer.indent
+
+        if passing?
+          writer.style(:green)
+        elsif failing?
+          if not writer.styling?
+            title = "#{title} (failed)"
+          end
+
+          writer.style(:bold, :red)
+        elsif pending?
+          writer.style(:faint)
+        end
+
+        writer.puts(title)
+
+        writer.indent!
+      end
+
+      handle TestFinished do |test_finished|
+        title = test_finished.title
+
+        if passing? && title.nil?
+          return
+        end
+
+        writer.deindent!
+      end
+
+      handle TestSkipped do |test_skipped|
+        title = test_skipped.title
+
+        if not writer.styling?
+          title = "#{title} (skipped)"
+        end
+
+        writer.
+          indent.
+          style(:yellow).
+          puts(title)
+      end
+
+      handle Failed do |failed|
+        message = failed.message
+
+        if failing?
+          self.failures += 1
+        end
+
+        writer
+          .indent
+          .style(:red)
+          .puts(message)
+      end
+
+      handle Detailed do |detailed|
+        if not detail?
+          return
+        end
+
+        text = detailed.text
+        quote = detailed.quote
+        heading = detailed.heading
+
+        comment(text, quote, heading)
+      end
+
+      handle Commented do |commented|
+        text = commented.text
+        quote = commented.quote
+        heading = commented.heading
+
+        comment(text, quote, heading)
+      end
+
+      def comment(text, quote, heading)
+        if not heading.nil?
+          writer.
+            indent.
+            style(:bold, :underline).
+            puts(heading)
+
+          if not writer.styling?
+            writer.
+              indent.
+              puts('- - -')
+          end
+        end
+
+        if text.empty?
+          writer.
+            indent.
+            style(:faint, :italic).
+            puts('(empty)')
+          return
+        end
+
+        if not quote
+          writer.
+            indent.
+            puts(text)
+        else
+          text.each_line(chomp: true) do |line|
+            writer.
+              indent.
+              style(:faint).
+              print('> ').
+              style(:reset_intensity).
+              puts(line)
+          end
+        end
+      end
+
+      def current_writer
+        if initial? || pending?
+          pending_writer
+        elsif passing?
+          passing_writer
+        elsif failing?
+          failing_writer
+        end
+      end
+      alias :writer :current_writer
+
+      def branch
+        if branch_count.zero?
+          self.mode = Mode.pending
+
+          pending_writer.sync = false
+
+          parent_writer = pending_writer
+        else
+          parent_writer = passing_writer
+        end
+
+        self.branch_count += 1
+
+        self.passing_writer, self.failing_writer = parent_writer.branch
+      end
+
+      def merge(result)
+        self.branch_count -= 1
+
+        if not branched?
+          pending_writer.sync = true
+
+          self.mode = Mode.initial
+        end
+
+        if result
+          writer = passing_writer
+        else
+          writer = failing_writer
+        end
+
+        writer.flush
+
+        self.passing_writer = writer.device
+        self.failing_writer = writer.alternate_device
+      end
+
+      def branched?
+        branch_count > 0
+      end
+
+      def initial?
+        mode == Mode.initial
+      end
+
+      def pending?
+        mode == Mode.pending
+      end
+
+      def passing?
+        mode == Mode.passing
+      end
+
+      def failing?
+        mode == Mode.failing
+      end
+
+      def detail?
+        Detail.detail?(detail_policy, mode)
+      end
+
+      module Mode
+        def self.initial = :initial
+        def self.pending = :pending
+        def self.passing = :passing
+        def self.failing = :failing
+      end
+
+      module Detail
+        Error = Class.new(RuntimeError)
+
+        def self.detail?(policy, mode)
+          assure_detail(policy, mode)
+        end
+
+        def self.assure_detail(policy, mode=nil)
+          mode ||= Mode.initial
+
+          case policy
+          when on
+            true
+          when off
+            false
+          when failure
+            if mode == Mode.failing || mode == Mode.initial
+              true
+            else
+              false
+            end
+          else
+            raise Error, "Unknown detail policy #{policy.inspect}"
+          end
+        end
+
+        def self.on = :on
+        def self.off = :off
+        def self.failure = :failure
+
+        def self.default
+          policy = ENV.fetch('TEST_BENCH_DETAIL') do
+            return default!
+          end
+
+          policy.to_sym
+        end
+
+        def self.default!
+          :failure
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/projection.rb

@@ -0,0 +1,28 @@
+module TestBench
+  class Session
+    class Projection
+      include Telemetry::Sink::Projection
+      include Events
+
+      receiver_name :session
+
+      apply Failed do
+        session.record_failure
+      end
+
+      apply TestSkipped do
+        session.record_skip
+      end
+
+      apply ContextSkipped do
+        session.record_skip
+      end
+
+      apply TestFinished do |test_finished|
+        if test_finished.result
+          session.record_assertion
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/session.rb

@@ -23,77 +23,55 @@ module TestBench
     end
     attr_writer :skip_sequence
 
-    def self.build(*sinks)
+    def self.build(&block)
       instance = new
-      TestBench::Telemetry.configure(instance, *sinks)
-      instance
-    end
-
-    def self.configure(receiver, *sinks, attr_name: nil)
-      attr_name ||= :test_session
 
-      instance = build(*sinks)
-      receiver.public_send(:"#{attr_name}=", instance)
-    end
+      Telemetry.configure(instance)
 
-    def start(process_count)
-      telemetry.record(Events::Started.new(process_count))
-    end
-
-    def abort(abort_process_id)
-      record_failure
+      if not block.nil?
+        block.(instance.telemetry)
+      end
 
-      telemetry.record(Events::Aborted.new(abort_process_id))
+      instance
     end
 
-    def finish(process_count)
-      result = !failed?
+    def self.configure(receiver, session: nil, attr_name: nil, &block)
+      session ||= Store.fetch
+      attr_name ||= :session
 
-      telemetry.record(Events::Finished.new(result, process_count))
+      instance = session
+      receiver.public_send(:"#{attr_name}=", instance)
     end
 
-    def file(path)
-      original_failure_sequence = failure_sequence
-
-      telemetry.record(Events::FileStarted.new(path))
-
-      source = File.read(path)
-
-      begin
-        TOPLEVEL_BINDING.eval(source, path)
-      rescue Failure
-      end
-
-      result = !failed?(original_failure_sequence)
-
-      telemetry.record(Events::FileFinished.new(path, result))
-
-      result
+    def passed?
+      asserted? && !failed? && !skipped?
     end
 
     def fixture(name, &block)
       original_failure_sequence = failure_sequence
 
-      telemetry.record(Events::FixtureStarted.new(name))
+      record_event(Events::FixtureStarted.new(name))
 
       begin
         block.()
+
       rescue Failure
-      end
 
-      result = !failed?(original_failure_sequence)
+      ensure
+        result = !failed?(original_failure_sequence)
 
-      telemetry.record(Events::FixtureFinished.new(name, result))
+        record_event(Events::FixtureFinished.new(name, result))
+      end
 
       result
     end
 
-    def detail(text)
-      telemetry.record(Events::Detailed.new(text))
+    def detail(text, quote, heading=nil)
+      record_event(Events::Detailed.new(text, quote, heading))
     end
 
-    def comment(comment)
-      telemetry.record(Events::Commented.new(comment))
+    def comment(text, quote, heading=nil)
+      record_event(Events::Commented.new(text, quote, heading))
     end
 
     def context!(...)
@@ -105,13 +83,14 @@ module TestBench
 
     def context(title=nil, &block)
       if block.nil?
-        telemetry.record(Events::ContextSkipped.new(title))
+        record_skip
+        record_event(Events::ContextSkipped.new(title))
         return
       end
 
       original_failure_sequence = failure_sequence
 
-      telemetry.record(Events::ContextStarted.new(title))
+      record_event(Events::ContextStarted.new(title))
 
       begin
         block.()
@@ -121,7 +100,7 @@ module TestBench
       ensure
         result = !failed?(original_failure_sequence)
 
-        telemetry.record(Events::ContextFinished.new(title, result))
+        record_event(Events::ContextFinished.new(title, result))
       end
 
       result
@@ -134,16 +113,17 @@ module TestBench
       end
     end
 
-    def test(path, line_number, title=nil, &block)
+    def test(title=nil, &block)
       if block.nil?
-        telemetry.record(Events::TestSkipped.new(title))
+        record_skip
+        record_event(Events::TestSkipped.new(title))
         return
       end
 
       original_failure_sequence = failure_sequence
       original_assertion_sequence = assertion_sequence
 
-      telemetry.record(Events::TestStarted.new(title))
+      record_event(Events::TestStarted.new(title))
 
       begin
         block.()
@@ -153,7 +133,7 @@ module TestBench
         if result
           if not asserted?(original_assertion_sequence)
             failure_message = Session.no_assertion_message
-            fail(failure_message, path, line_number)
+            fail(failure_message)
           end
         end
 
@@ -161,30 +141,28 @@ module TestBench
         result = false
 
       ensure
-        telemetry.record(Events::TestFinished.new(title, result))
+        record_event(Events::TestFinished.new(title, result))
       end
 
       result
     end
 
-    def assert(result, path, line_number)
+    def assert(result)
       failure_message = Session.assertion_failure_message
 
-      if result != true && result != false
-        raise TypeError, "Value #{result.inspect} isn't a boolean"
-      end
-
       record_assertion
 
       if result == false
-        fail(failure_message, path, line_number)
+        fail(failure_message)
       end
     end
 
-    def fail(message, path, line_number)
+    def fail(message=nil)
+      message ||= self.class.default_failure_message
+
       record_failure
 
-      telemetry.record(Events::Failed.new(message, path, line_number))
+      record_event(Events::Failed.new(message))
 
       raise Failure, message
     end
@@ -205,6 +183,10 @@ module TestBench
       compare_sequence != failure_sequence
     end
 
+    def record_event(event)
+      telemetry.record(event)
+    end
+
     def record_failure
       self.failure_sequence += 1
     end
@@ -217,16 +199,20 @@ module TestBench
       self.skip_sequence += 1
     end
 
-    def self.assertion_failure_message
-      "Assertion failed"
+    def self.default_failure_message
+      'Failed'
     end
 
-    def self.no_assertion_message
-      "Test didn't perform an assertion"
+    def self.assertion_failure_message
+      "Assertion failed"
     end
 
     def self.abort_message
       "Abort"
     end
+
+    def self.no_assertion_message
+      "Test didn't perform an assertion"
+    end
   end
 end

data/lib/test_bench/session/store.rb

@@ -0,0 +1,59 @@
+module TestBench
+  class Session
+    class Store
+      PutError = Class.new(RuntimeError)
+
+      attr_accessor :put_session
+
+      def self.configure(receiver, attr_name: nil)
+        attr_name ||= :session_store
+
+        receiver.public_send(:"#{attr_name}=", instance)
+      end
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def self.put(...) = instance.put(...)
+      def self.put?(...) = instance.put?(...)
+      def self.reset(...) = instance.reset(...)
+      def self.get(...) = instance.get(...)
+      def self.fetch(...) = instance.fetch(...)
+
+      def put(session)
+        if not put_session.nil?
+          raise PutError, "Already put a session"
+        end
+
+        self.put_session = session
+      end
+
+      def put?(session=nil)
+        if not session.nil?
+          put_session == session
+        else
+          !put_session.nil?
+        end
+      end
+
+      def reset(session=nil)
+        self.put_session = session
+      end
+
+      def get
+        put_session
+      end
+
+      def fetch
+        self.put_session ||= new_session
+      end
+
+      def new_session
+        Session.build do |telemetry|
+          Output.register_telemetry(telemetry)
+        end
+      end
+    end
+  end
+end