test_bench-telemetry 2.0.0.0

data/lib/test_bench/telemetry/event/type.rb

@@ -0,0 +1,27 @@
+module TestBench
+  class Telemetry
+    module Event
+      module Type
+        def self.get(class_name)
+          *, constant_name = class_name.split('::')
+
+          constant_name.to_sym
+        end
+
+        def self.method_cased(event_type)
+          pascal_cased = event_type.to_s
+
+          underscore_cased = pascal_cased.gsub(%r{(?:\A|[a-z])[A-Z]+}) do |match_text|
+            if ('a'..'z').include?(match_text[0])
+              match_text.insert(1, '_')
+            end
+            match_text.downcase!
+            match_text
+          end
+
+          underscore_cased.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/event.rb

@@ -0,0 +1,41 @@
+module TestBench
+  class Telemetry
+    module Event
+      def self.define(*attribute_names)
+        Struct.new(*attribute_names, :time) do
+          include Event
+        end
+      end
+
+      def self.included(cls)
+        cls.class_exec do
+          extend EventType
+        end
+      end
+
+      def self.each_event_type(&block)
+        Events.constants(false).each(&block)
+      end
+
+      def event_type
+        self.class.event_type
+      end
+
+      def dump
+        Serialization.dump(self)
+      end
+
+      def self.load(data, event_namespace=nil)
+        event_namespace ||= Events
+
+        Serialization.load(data, event_namespace)
+      end
+
+      module EventType
+        def event_type
+          @event_type ||= Type.get(name)
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/sink/capture/path.rb

@@ -0,0 +1,69 @@
+module TestBench
+  class Telemetry
+    module Sink
+      class Capture
+        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 copy?(compare_path)
+            eql?(compare_path) && !equal?(compare_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/telemetry/sink/capture/record/generate.rb

@@ -0,0 +1,49 @@
+module TestBench
+  class Telemetry
+    module Sink
+      class Capture
+        class Record
+          class Generate
+            include Event::Events
+
+            def path
+              @path ||= Path.new
+            end
+            attr_writer :path
+
+            def detail_level
+              @detail_level ||= 0
+            end
+            attr_writer :detail_level
+
+            def call(event)
+              case event
+              when TestStarted, ContextEntered
+                path.push(event.title)
+              when TestFinished, ContextExited
+                path.pop(event.title)
+              when DetailIncreased
+                self.detail_level += 1
+              when DetailDecreased
+                self.detail_level -= 1
+              end
+
+              record = Record.build(event, path, detail_level)
+
+              case event
+              when TestFinished, ContextExited
+                title = event.title
+                record.path.push(title)
+              when Commented
+                comment = event.comment
+                record.path.push(comment)
+              end
+
+              record
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/sink/capture/record.rb

@@ -0,0 +1,73 @@
+module TestBench
+  class Telemetry
+    module Sink
+      class Capture
+        Record = Struct.new(:event, :path, :detail_level) do
+          def self.build(event, path, detail_level)
+            instance = new
+            instance.event = event
+            instance.detail_level = detail_level
+
+            path.copy(instance)
+
+            instance
+          end
+
+          def match?(*path_segments, detail: nil, detail_level: nil, &block)
+            if not path_segments?(*path_segments)
+              false
+            elsif not detail?(detail)
+              false
+            elsif not detail_level?(detail_level)
+              false
+            elsif not block?(&block)
+              false
+            else
+              true
+            end
+          end
+
+          def detail_match?(match)
+            if match.nil?
+              true
+            elsif match
+              detail_level > 0
+            else
+              detail_level.zero?
+            end
+          end
+          alias :detail? :detail_match?
+
+          def detail_level_match?(detail_level)
+            if detail_level.nil?
+              true
+            else
+              detail_level == self.detail_level
+            end
+          end
+          alias :detail_level? :detail_level_match?
+
+          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

data/lib/test_bench/telemetry/sink/capture.rb

@@ -0,0 +1,55 @@
+module TestBench
+  class Telemetry
+    module Sink
+      class Capture
+        include Sink
+
+        MatchError = Class.new(RuntimeError)
+
+        def raw_records
+          @raw_records ||= []
+        end
+
+        def generate_record
+          @generate_record ||= Record::Generate.new
+        end
+        attr_writer :generate_record
+
+        def call(event)
+          record = generate_record.(event)
+
+          raw_records.push(record)
+
+          record
+        end
+
+        def one_record?(...)
+          record = one_record(...)
+
+          !record.nil?
+        end
+
+        def one_record(...)
+          records = records(...)
+
+          if records.count > 1
+            raise MatchError, "More than one record matches (Matching Records: #{records.count})"
+          end
+
+          records.first
+        end
+
+        def any_record?(...)
+          records(...).any?
+        end
+        alias :record? :any_record?
+
+        def records(...)
+          raw_records.select do |record|
+            record.match?(...)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/sink/file.rb

@@ -0,0 +1,31 @@
+module TestBench
+  class Telemetry
+    module Sink
+      class File
+        include Sink
+
+        attr_reader :io
+
+        def initialize(io)
+          @io = io
+        end
+
+        def self.open(path, &block)
+          ::File.open(path, 'w') do |io|
+            instance = new(io)
+
+            block.(instance, io)
+
+            return instance
+          end
+        end
+
+        def call(event)
+          data = event.dump
+
+          io.write(data)
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/sink/handler.rb

@@ -0,0 +1,90 @@
+module TestBench
+  class Telemetry
+    module Sink
+      module Handler
+        def self.included(cls)
+          cls.class_exec do
+            include Sink
+
+            extend HandlerMethod
+            extend HandleMacro
+
+            include Event::Events
+          end
+        end
+
+        def handle(event)
+          handles = handle?(event)
+
+          if handles
+            handler_method = handler_method(event)
+
+            parameters = method(handler_method).parameters
+
+            final_parameter_type, _ = parameters.last
+            if not final_parameter_type == :rest
+              parameter_count = parameters.count
+
+              arguments = event.values[0...parameter_count]
+            else
+              arguments = event.values
+            end
+
+            __send__(handler_method, *arguments)
+
+            true
+          else
+            false
+          end
+        end
+        alias :call :handle
+
+        def handle?(event_or_event_type)
+          handler_method = handler_method(event_or_event_type)
+
+          not handler_method.nil?
+        end
+
+        def handler_method(event_or_event_type)
+          handler_method = self.class.handler_method(event_or_event_type)
+
+          if respond_to?(handler_method)
+            handler_method
+          else
+            nil
+          end
+        end
+
+        module HandleMacro
+          def handle_macro(event_class, &block)
+            event_type = event_class
+
+            handler_method = HandlerMethod.get(event_type)
+
+            define_method(handler_method, &block)
+          end
+          alias :handle :handle_macro
+        end
+
+        module HandlerMethod
+          def handler_method(event_or_event_type)
+            HandlerMethod.get(event_or_event_type)
+          end
+
+          def self.get(event_or_event_type)
+            if event_or_event_type.is_a?(Symbol)
+              event_type = event_or_event_type
+            else
+              event = event_or_event_type
+              event_type = event.event_type
+            end
+
+            event_type_method_cased = Event::Type.method_cased(event_type)
+
+            :"handle_#{event_type_method_cased}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/substitute.rb

@@ -0,0 +1,65 @@
+module TestBench
+  class Telemetry
+    module Substitute
+      def self.build
+        Telemetry.build
+      end
+
+      class Telemetry < Telemetry
+        def capture_sink
+          @capture_sink ||= Sink::Capture.new
+        end
+
+        def self.build
+          instance = new
+          instance.register(instance.capture_sink)
+          instance
+        end
+
+        Event.each_event_type do |event_type|
+          event_type_method_cased = Event::Type.method_cased(event_type)
+
+          module_eval(<<~RUBY, __FILE__, __LINE__)
+          def one_#{event_type_method_cased}_record?(*arguments, **keyword_arguments, &block)
+            one_record?(*arguments, **keyword_arguments) do |compare_event_type, *event_values|
+              if compare_event_type == #{event_type.inspect}
+                block.(*event_values)
+              end
+            end
+          end
+
+          def one_#{event_type_method_cased}_record(*arguments, **keyword_arguments, &block)
+            one_record(*arguments, **keyword_arguments) do |compare_event_type, *event_values|
+              if compare_event_type == #{event_type.inspect}
+                block.(*event_values)
+              end
+            end
+          end
+
+          def any_#{event_type_method_cased}_record?(*arguments, **keyword_arguments, &block)
+            any_record?(*arguments, **keyword_arguments) do |compare_event_type, *event_values|
+              if compare_event_type == #{event_type.inspect}
+                block.(*event_values)
+              end
+            end
+          end
+          alias :#{event_type_method_cased}_record? :any_#{event_type_method_cased}_record?
+
+          def #{event_type_method_cased}_records(*arguments, **keyword_arguments, &block)
+            records(*arguments, **keyword_arguments) do |compare_event_type, *event_values|
+              if compare_event_type == #{event_type.inspect}
+                block.(*event_values)
+              end
+            end
+          end
+          RUBY
+        end
+
+        def one_record?(...) = capture_sink.one_record?(...)
+        def one_record(...) = capture_sink.one_record(...)
+        def any_record?(...) = capture_sink.any_record?(...)
+        def records(...) = capture_sink.records(...)
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/telemetry.rb

@@ -0,0 +1,68 @@
+module TestBench
+  class Telemetry
+    include Event::Events
+
+    RegistrationError = Class.new(RuntimeError)
+
+    def sinks
+      @sinks ||= []
+    end
+
+    def self.build(*sinks)
+      instance = new
+
+      sinks.each do |sink|
+        instance.register(sink)
+      end
+
+      instance
+    end
+
+    def self.configure(receiver, *sinks, attr_name: nil)
+      attr_name ||= :telemetry
+
+      instance = build(*sinks)
+      receiver.public_send(:"#{attr_name}=", instance)
+    end
+
+    def record(event, now=nil)
+      event.time ||= current_time(now)
+
+      sinks.each do |sink|
+        sink.(event)
+      end
+
+      event
+    end
+
+    def register(sink)
+      if registered?(sink)
+        raise RegistrationError, "Already registered #{sink.inspect}"
+      end
+
+      sinks << sink
+    end
+
+    def registered?(sink)
+      sinks.include?(sink)
+    end
+
+    Event.each_event_type do |event_type|
+      event_class = Event.const_get(event_type)
+
+      event_type_method_cased = Event::Type.method_cased(event_type)
+
+      module_eval(<<~RUBY, __FILE__, __LINE__)
+      def record_#{event_type_method_cased}(*values)
+        event = #{event_class}.new(*values)
+
+        record(event)
+      end
+      RUBY
+    end
+
+    def current_time(now)
+      now || ::Time.now
+    end
+  end
+end

data/lib/test_bench/telemetry.rb

@@ -0,0 +1,19 @@
+require 'test_bench/random'
+
+require 'test_bench/telemetry/event'
+require 'test_bench/telemetry/event/type'
+require 'test_bench/telemetry/event/serialization'
+require 'test_bench/telemetry/event/events'
+
+require 'test_bench/telemetry/sink/handler'
+
+require 'test_bench/telemetry/sink/capture/path'
+require 'test_bench/telemetry/sink/capture/record'
+require 'test_bench/telemetry/sink/capture/record/generate'
+require 'test_bench/telemetry/sink/capture'
+
+require 'test_bench/telemetry/sink/file'
+
+require 'test_bench/telemetry/telemetry'
+
+require 'test_bench/telemetry/substitute'