test_bench-session 2.0.0.0

data/lib/test_bench/session/controls/failure.rb

@@ -0,0 +1,30 @@
+module TestBench
+  class Session
+    module Controls
+      module Failure
+        module Message
+          def self.example(suffix=nil)
+            suffix = " #{suffix}" if not suffix.nil?
+
+            "Some failure message#{suffix}"
+          end
+          def self.random = example(Controls::Random.string)
+        end
+
+        module Path
+          def self.example(suffix=nil)
+            suffix = "_#{suffix}" if not suffix.nil?
+
+            "path/to/some_file#{suffix}.rb"
+          end
+          def self.random = example(Controls::Random.string)
+        end
+
+        module LineNumber
+          def self.example = 11
+          def self.random = Controls::Random.integer % 1111
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/controls/file.rb

@@ -0,0 +1,58 @@
+module TestBench
+  class Session
+    module Controls
+      module File
+        def self.example(contents=nil)
+          contents ||= self.contents
+
+          path = TestBench::Telemetry::Controls::File::Temporary.example
+
+          ::File.write(path, contents)
+
+          path
+        end
+
+        def self.contents = Pass.contents
+
+        module Failure
+          def self.example(session: nil)
+            contents = contents(session:)
+
+            File.example(contents)
+          end
+
+          def self.contents(session: nil)
+            session ||= Session.new
+
+            <<~RUBY
+            session = ObjectSpace._id2ref(#{session.object_id})
+            session.assert(false, __FILE__, __LINE__)
+            RUBY
+          end
+        end
+
+        module Pass
+          def self.example
+            File.example(contents)
+          end
+
+          def self.contents
+            ''
+          end
+        end
+
+        module Path
+          def self.example(suffix=nil)
+            extension = '.rb'
+
+            filename = TestBench::Telemetry::Controls::File::Name.example(suffix, extension:)
+
+            ::File.join('some_dir', 'some_other_dir', filename)
+          end
+
+          def self.random = example(Random.string)
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/controls/fixture.rb

@@ -0,0 +1,16 @@
+module TestBench
+  class Session
+    module Controls
+      module Fixture
+        module Name
+          def self.example(suffix=nil)
+            suffix = "_#{suffix}" if not suffix.nil?
+
+            "SomeNamespace::SomeFixture#{suffix}"
+          end
+          def self.random = example(Random.string)
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/controls/process_id.rb

@@ -0,0 +1,7 @@
+module TestBench
+  class Session
+    module Controls
+      ProcessID = TestBench::Telemetry::Controls::ProcessID
+    end
+  end
+end

data/lib/test_bench/session/controls/random.rb

@@ -0,0 +1,7 @@
+module TestBench
+  class Session
+    module Controls
+      Random = TestBench::Telemetry::Controls::Random
+    end
+  end
+end

data/lib/test_bench/session/controls/result.rb

@@ -0,0 +1,12 @@
+module TestBench
+  class Session
+    module Controls
+      module Result
+        def self.example = pass
+        def self.pass = true
+        def self.failure = false
+        def self.random = Random.boolean
+      end
+    end
+  end
+end

data/lib/test_bench/session/controls/time.rb

@@ -0,0 +1,7 @@
+module TestBench
+  class Session
+    module Controls
+      Time = TestBench::Telemetry::Controls::Time
+    end
+  end
+end

data/lib/test_bench/session/controls/title.rb

@@ -0,0 +1,27 @@
+module TestBench
+  class Session
+    module Controls
+      module Title
+        module Test
+          def self.example(suffix=nil)
+            suffix = " #{suffix}" if not suffix.nil?
+
+            "Some test#{suffix}"
+          end
+          def self.other_example = "Some other test"
+          def self.random = example(Random.string)
+        end
+
+        module Context
+          def self.example(suffix=nil)
+            suffix = " #{suffix}" if not suffix.nil?
+
+            "Some Context#{suffix}"
+          end
+          def self.other_example = "Some Other Context"
+          def self.random = example(Random.string)
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/controls.rb

@@ -0,0 +1,36 @@
+require 'test_bench/telemetry/controls'
+
+require 'test_bench/session/controls/random'
+require 'test_bench/session/controls/time'
+require 'test_bench/session/controls/process_id'
+require 'test_bench/session/controls/result'
+require 'test_bench/session/controls/exception'
+
+require 'test_bench/session/controls/failure'
+require 'test_bench/session/controls/title'
+require 'test_bench/session/controls/comment'
+require 'test_bench/session/controls/detail'
+require 'test_bench/session/controls/fixture'
+require 'test_bench/session/controls/file'
+
+require 'test_bench/session/controls/events/failed'
+require 'test_bench/session/controls/events/test_started'
+require 'test_bench/session/controls/events/test_finished'
+require 'test_bench/session/controls/events/test_skipped'
+require 'test_bench/session/controls/events/context_started'
+require 'test_bench/session/controls/events/context_finished'
+require 'test_bench/session/controls/events/context_skipped'
+require 'test_bench/session/controls/events/commented'
+require 'test_bench/session/controls/events/detailed'
+require 'test_bench/session/controls/events/fixture_started'
+require 'test_bench/session/controls/events/fixture_finished'
+require 'test_bench/session/controls/events/file_started'
+require 'test_bench/session/controls/events/file_finished'
+require 'test_bench/session/controls/events/started'
+require 'test_bench/session/controls/events/aborted'
+require 'test_bench/session/controls/events/finished'
+require 'test_bench/session/controls/events'
+
+require 'test_bench/session/controls/capture_sink/path'
+require 'test_bench/session/controls/capture_sink/event'
+require 'test_bench/session/controls/capture_sink/record'

data/lib/test_bench/session/events.rb

@@ -0,0 +1,32 @@
+module TestBench
+  class Session
+    module Events
+      def self.each_type(&block)
+        constants(false).each(&block)
+      end
+
+      Failed = TestBench::Telemetry::Event.define(:message, :path, :line_number)
+
+      TestStarted = TestBench::Telemetry::Event.define(:title)
+      TestFinished = TestBench::Telemetry::Event.define(:title, :result)
+      TestSkipped = TestBench::Telemetry::Event.define(:title)
+
+      ContextStarted = TestBench::Telemetry::Event.define(:title)
+      ContextFinished = TestBench::Telemetry::Event.define(:title, :result)
+      ContextSkipped = TestBench::Telemetry::Event.define(:title)
+
+      Commented = TestBench::Telemetry::Event.define(:text)
+      Detailed = TestBench::Telemetry::Event.define(:text)
+
+      FixtureStarted = TestBench::Telemetry::Event.define(:name)
+      FixtureFinished = TestBench::Telemetry::Event.define(:name, :result)
+
+      FileStarted = TestBench::Telemetry::Event.define(:path)
+      FileFinished = TestBench::Telemetry::Event.define(:path, :result)
+
+      Started = TestBench::Telemetry::Event.define(:process_count)
+      Aborted = TestBench::Telemetry::Event.define(:abort_process_id)
+      Finished = TestBench::Telemetry::Event.define(:result, :process_count)
+    end
+  end
+end

data/lib/test_bench/session/session.rb

@@ -0,0 +1,232 @@
+module TestBench
+  class Session
+    Failure = Class.new(RuntimeError)
+    Abort = Class.new(Failure)
+
+    def telemetry
+      @telemetry ||= TestBench::Telemetry::Substitute.build
+    end
+    attr_writer :telemetry
+
+    def failure_sequence
+      @failure_sequence ||= 0
+    end
+    attr_writer :failure_sequence
+
+    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(*sinks)
+      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
+
+    def start(process_count)
+      telemetry.record(Events::Started.new(process_count))
+    end
+
+    def abort(abort_process_id)
+      record_failure
+
+      telemetry.record(Events::Aborted.new(abort_process_id))
+    end
+
+    def finish(process_count)
+      result = !failed?
+
+      telemetry.record(Events::Finished.new(result, process_count))
+    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
+    end
+
+    def fixture(name, &block)
+      original_failure_sequence = failure_sequence
+
+      telemetry.record(Events::FixtureStarted.new(name))
+
+      begin
+        block.()
+      rescue Failure
+      end
+
+      result = !failed?(original_failure_sequence)
+
+      telemetry.record(Events::FixtureFinished.new(name, result))
+
+      result
+    end
+
+    def detail(text)
+      telemetry.record(Events::Detailed.new(text))
+    end
+
+    def comment(comment)
+      telemetry.record(Events::Commented.new(comment))
+    end
+
+    def context!(...)
+      if context(...) == false
+        message = Session.abort_message
+        raise Abort, message
+      end
+    end
+
+    def context(title=nil, &block)
+      if block.nil?
+        telemetry.record(Events::ContextSkipped.new(title))
+        return
+      end
+
+      original_failure_sequence = failure_sequence
+
+      telemetry.record(Events::ContextStarted.new(title))
+
+      begin
+        block.()
+
+      rescue Failure
+
+      ensure
+        result = !failed?(original_failure_sequence)
+
+        telemetry.record(Events::ContextFinished.new(title, result))
+      end
+
+      result
+    end
+
+    def test!(...)
+      if test(...) == false
+        message = Session.abort_message
+        raise Abort, message
+      end
+    end
+
+    def test(path, line_number, title=nil, &block)
+      if block.nil?
+        telemetry.record(Events::TestSkipped.new(title))
+        return
+      end
+
+      original_failure_sequence = failure_sequence
+      original_assertion_sequence = assertion_sequence
+
+      telemetry.record(Events::TestStarted.new(title))
+
+      begin
+        block.()
+
+        result = !failed?(original_failure_sequence)
+
+        if result
+          if not asserted?(original_assertion_sequence)
+            failure_message = Session.no_assertion_message
+            fail(failure_message, path, line_number)
+          end
+        end
+
+      rescue Failure
+        result = false
+
+      ensure
+        telemetry.record(Events::TestFinished.new(title, result))
+      end
+
+      result
+    end
+
+    def assert(result, path, line_number)
+      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)
+      end
+    end
+
+    def fail(message, path, line_number)
+      record_failure
+
+      telemetry.record(Events::Failed.new(message, path, line_number))
+
+      raise Failure, message
+    end
+
+    def asserted?(compare_sequence=nil)
+      compare_sequence ||= 0
+
+      compare_sequence != assertion_sequence
+    end
+
+    def record_assertion
+      self.assertion_sequence += 1
+    end
+
+    def failed?(compare_sequence=nil)
+      compare_sequence ||= 0
+
+      compare_sequence != failure_sequence
+    end
+
+    def record_failure
+      self.failure_sequence += 1
+    end
+
+    def skipped?
+      skip_sequence != 0
+    end
+
+    def record_skip
+      self.skip_sequence += 1
+    end
+
+    def self.assertion_failure_message
+      "Assertion failed"
+    end
+
+    def self.no_assertion_message
+      "Test didn't perform an assertion"
+    end
+
+    def self.abort_message
+      "Abort"
+    end
+  end
+end

data/lib/test_bench/session/substitute.rb

@@ -0,0 +1,93 @@
+module TestBench
+  class Session
+    module Substitute
+      def self.build
+        Session.build
+      end
+
+      class Session < Session
+        attr_accessor :result
+
+        def self.build
+          instance = new
+
+          telemetry = instance.telemetry
+          Telemetry::CaptureSink.configure(telemetry, attr_name: :sink)
+
+          telemetry.register(telemetry.sink)
+
+          instance
+        end
+
+        def file(path)
+          telemetry.record(Events::FileStarted.new(path))
+
+          telemetry.record(Events::FileFinished.new(path, result))
+
+          result
+        end
+
+        Events.each_type do |event_type|
+          event_type_method_cased = TestBench::Telemetry::Event::Type.method_cased(event_type)
+
+          event_class = Events.const_get(event_type, false)
+
+          module_eval(<<~RUBY, __FILE__, __LINE__)
+          def one_#{event_type_method_cased}_event?(...)
+            one_event?(#{event_class}, ...)
+          end
+
+          def one_#{event_type_method_cased}_event(...)
+            one_event(#{event_class}, ...)
+          end
+
+          def any_#{event_type_method_cased}_event?(...)
+            any_event?(#{event_class}, ...)
+          end
+          alias :#{event_type_method_cased}_event? :any_#{event_type_method_cased}_event?
+
+          def #{event_type_method_cased}_events(...)
+            events(#{event_class}, ...)
+          end
+          RUBY
+        end
+
+        def one_event?(...) = telemetry.one_event?(...)
+        def one_event(...) = telemetry.one_event(...)
+        def any_event?(...) = telemetry.any_event?(...)
+        alias :event? :any_event?
+        def events(...) = telemetry.events(...)
+
+        alias :failure? :failed_event?
+        alias :one_failure? :one_failed_event?
+
+        alias :test? :test_finished_event?
+        alias :one_test? :one_test_finished_event?
+
+        alias :context? :context_finished_event?
+        alias :one_context? :one_context_finished_event?
+
+        alias :comment? :commented_event?
+        alias :one_comment? :one_commented_event?
+
+        alias :detail? :detailed_event?
+        alias :one_detail? :one_detailed_event?
+
+        alias :fixture? :fixture_finished_event?
+        alias :one_fixture? :one_fixture_finished_event?
+
+        alias :file? :file_finished_event?
+        alias :one_file? :one_file_finished_event?
+
+        alias :started? :started_event?
+        alias :one_started? :one_started_event?
+
+        alias :finished? :finished_event?
+        alias :one_finished? :one_finished_event?
+
+        alias :aborted? :aborted_event?
+        alias :one_aborted? :one_aborted_event?
+      end
+    end
+  end
+end

data/lib/test_bench/session/telemetry/capture_sink/path.rb

@@ -0,0 +1,65 @@
+module TestBench
+  class Session
+    module Telemetry
+      class CaptureSink
+        class Path
+          def segments
+            @segments ||= []
+          end
+          attr_writer :segments
+
+          def match?(*segments, segment)
+            if not segment == self.segments.last
+              return false
+            end
+
+            segment_iterator = self.segments.to_enum
+
+            control_segments = [*segments, segment]
+
+            control_segments.all? do |control_segment|
+              begin
+                next_segment = segment_iterator.next
+              end until next_segment == control_segment
+              true
+
+            rescue StopIteration
+              false
+            end
+          end
+
+          def push_segment(segment)
+            segments << segment
+          end
+          alias :push :push_segment
+          alias :<< :push
+
+          def pop_segment(compare_segment=nil)
+            segments.pop
+          end
+          alias :pop :pop_segment
+
+          def copy(receiver)
+            path = self.class.new
+
+            segments.each do |segment|
+              path << segment
+            end
+
+            receiver.path = path
+            path
+          end
+
+          def eql?(compare)
+            if compare.is_a?(self.class)
+              segments == compare.segments
+            else
+              false
+            end
+          end
+          alias :== :eql?
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/telemetry/capture_sink/record.rb

@@ -0,0 +1,39 @@
+module TestBench
+  class Session
+    module Telemetry
+      class CaptureSink
+        Record = Struct.new(:event, :path) do
+          def match?(*path_segments, &block)
+            if not path_segments?(*path_segments)
+              false
+            elsif not block?(&block)
+              false
+            else
+              true
+            end
+          end
+
+          def path_segments_match?(*segments)
+            if segments.empty?
+              true
+            else
+              path.match?(*segments)
+            end
+          end
+          alias :path_segments? :path_segments_match?
+
+          def block_match?(&block)
+            if block.nil?
+              true
+            elsif block.(event.event_type, *event.values)
+              true
+            else
+              false
+            end
+          end
+          alias :block? :block_match?
+        end
+      end
+    end
+  end
+end