test_bench-telemetry 2.0.0.1 → 2.1.0.1

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

@@ -5,48 +5,65 @@ module TestBench
         def self.included(cls)
           cls.class_exec do
             include Sink
+            include Receive
 
             extend HandlerMethod
             extend HandleMacro
+          end
+        end
 
-            include Event::Events
+        module Receive
+          def receive(event_data)
+            handle(event_data)
           end
         end
 
-        def handle(event)
-          handles = handle?(event)
+        def handle(event_or_event_data)
+          handles = handle?(event_or_event_data)
 
           if handles
-            handler_method = handler_method(event)
+            if event_or_event_data.is_a?(Event)
+              event = event_or_event_data
+            else
+              event_data = event_or_event_data
+              event_type = event_data.type
+              event_class = self.class.event_registry.get(event_type)
+
+              event = Event::Import.(event_data, event_class)
+            end
 
-            parameters = method(handler_method).parameters
+            handler_method = handler_method(event)
 
-            final_parameter_type, _ = parameters.last
-            if not final_parameter_type == :rest
-              parameter_count = parameters.count
+            if method(handler_method).parameters.any?
+              __send__(handler_method, event)
+            else
+              __send__(handler_method)
+            end
 
-              arguments = event.values[0...parameter_count]
+            event
+          elsif respond_to?(:handle_event_data)
+            if event_or_event_data.is_a?(Event)
+              event_data = Event::Export.(event_or_event_data)
             else
-              arguments = event.values
+              event_data = event_or_event_data
             end
 
-            __send__(handler_method, *arguments)
+            handle_event_data(event_data)
 
-            true
+            event_data
           else
-            false
+            nil
           end
         end
-        alias :call :handle
 
-        def handle?(event_or_event_type)
-          handler_method = handler_method(event_or_event_type)
+        def handle?(...)
+          handler_method = handler_method(...)
 
           not handler_method.nil?
         end
 
-        def handler_method(event_or_event_type)
-          handler_method = self.class.handler_method(event_or_event_type)
+        def handler_method(event_or_event_data)
+          handler_method = self.class.handler_method(event_or_event_data)
 
           if respond_to?(handler_method)
             handler_method
@@ -57,31 +74,38 @@ module TestBench
 
         module HandleMacro
           def handle_macro(event_class, &block)
-            event_type = event_class
+            event_registry.register(event_class)
+
+            event_type = event_class.event_type
 
             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)
+          def event_registry
+            @event_registry ||= EventRegistry.new
           end
+        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
+        module HandlerMethod
+          def handler_method(event_or_event_data)
+            if event_or_event_data.is_a?(Event)
+              event = event_or_event_data
               event_type = event.event_type
+            else
+              event_data = event_or_event_data
+              event_type = event_data.type
             end
 
-            event_type_method_cased = Event::Type.method_cased(event_type)
+            HandlerMethod.get(event_type)
+          end
+
+          def self.get(event_type)
+            event_name = Event::EventName.get(event_type)
 
-            :"handle_#{event_type_method_cased}"
+            :"handle_#{event_name}"
           end
         end
       end

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

@@ -0,0 +1,132 @@
+module TestBench
+  class Telemetry
+    module Sink
+      module Projection
+        def self.included(cls)
+          cls.class_exec do
+            include Sink
+            include Receive
+
+            extend ReceiverNameMacro
+
+            extend ApplyMethod
+            extend ApplyMacro
+          end
+        end
+
+        attr_accessor :receiver
+
+        def initialize(receiver)
+          @receiver = receiver
+        end
+
+        module Receive
+          def receive(event_data)
+            apply(event_data)
+          end
+        end
+
+        def apply(event_or_event_data)
+          applies = apply?(event_or_event_data)
+
+          if applies
+            if event_or_event_data.is_a?(Event)
+              event = event_or_event_data
+            else
+              event_data = event_or_event_data
+              event_type = event_data.type
+              event_class = self.class.event_registry.get(event_type)
+
+              event = Event::Import.(event_data, event_class)
+            end
+
+            apply_method = apply_method(event)
+
+            if method(apply_method).parameters.any?
+              __send__(apply_method, event)
+            else
+              __send__(apply_method)
+            end
+
+            event
+          elsif respond_to?(:apply_event_data)
+            if event_or_event_data.is_a?(Event)
+              event_data = Event::Export.(event_or_event_data)
+            else
+              event_data = event_or_event_data
+            end
+
+            apply_event_data(event_data)
+
+            event_data
+          else
+            nil
+          end
+        end
+        alias :call :apply
+
+        def apply?(...)
+          apply_method = apply_method(...)
+
+          not apply_method.nil?
+        end
+
+        def apply_method(event_or_event_data)
+          apply_method = self.class.apply_method(event_or_event_data)
+
+          if respond_to?(apply_method)
+            apply_method
+          else
+            nil
+          end
+        end
+
+        module ReceiverNameMacro
+          def receiver_name_macro(receiver_name)
+            define_method(receiver_name) do
+              receiver
+            end
+          end
+          alias :receiver_name :receiver_name_macro
+        end
+
+        module ApplyMacro
+          def apply_macro(event_class, &block)
+            event_registry.register(event_class)
+
+            event_type = event_class.event_type
+
+            apply_method = ApplyMethod.get(event_type)
+
+            define_method(apply_method, &block)
+          end
+          alias :apply :apply_macro
+
+          def event_registry
+            @event_registry ||= Handler::EventRegistry.new
+          end
+        end
+
+        module ApplyMethod
+          def apply_method(event_or_event_data)
+            if event_or_event_data.is_a?(Event)
+              event = event_or_event_data
+              event_type = event.event_type
+            else
+              event_data = event_or_event_data
+              event_type = event_data.type
+            end
+
+            ApplyMethod.get(event_type)
+          end
+
+          def self.get(event_type)
+            event_name = Event::EventName.get(event_type)
+
+            :"apply_#{event_name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/sink.rb

@@ -0,0 +1,11 @@
+module TestBench
+  class Telemetry
+    module Sink
+      ReceiveError = Class.new(RuntimeError)
+
+      def receive(event_data)
+        raise ReceiveError, "Sink #{self.class} doesn't implement receive"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module TestBench
+  class Telemetry
+    module Substitute
+      class Sink
+        MatchError = Class.new(RuntimeError)
+
+        include Telemetry::Sink
+
+        def self.read(path)
+          file_text = ::File.read(path)
+
+          instance = new
+
+          file_text.each_line do |event_data_text|
+            event_data = Telemetry::EventData.load(event_data_text)
+
+            instance.receive(event_data)
+          end
+
+          instance
+        end
+
+        def received_events
+          @received_events ||= []
+        end
+
+        def receive(event_data)
+          received_events << event_data
+        end
+
+        def received?(event_data)
+          received_events.include?(event_data)
+        end
+
+        def one_event?(...)
+          !one_event(...).nil?
+        end
+
+        def one_event(...)
+          events = events(...)
+
+          if events.count > 1
+            event_type = events.first.event_type
+            raise MatchError, "More than one event matches (Type: #{event_type.inspect}, Matching Events: #{events.count})"
+          end
+
+          events.first
+        end
+
+        def any_event?(...)
+          events(...).any?
+        end
+        alias :event? :any_event?
+
+        def events(event_class, **attributes)
+          event_type = event_class.event_type
+
+          events = []
+
+          received_events.each do |event_data|
+            event_types_correspond = event_data.type == event_type
+
+            if event_types_correspond
+              event = Event::Import.(event_data, event_class)
+
+              attributes_correspond = attributes.all? do |attribute, compare_value|
+                value = event.public_send(attribute)
+
+                value == compare_value
+              end
+
+              if attributes_correspond
+                events << event
+              end
+            end
+          end
+
+          events
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/substitute.rb

@@ -6,67 +6,26 @@ module TestBench
       end
 
       class Telemetry < Telemetry
-        def capture_sink
-          @capture_sink ||= Sink::Capture.new
+        attr_accessor :process_id
+        attr_accessor :current_time
+
+        def sink
+          @sink ||= Substitute::Sink.new
         end
+        attr_writer :sink
 
         def self.build
           instance = new
-          instance.register(instance.capture_sink)
+          instance.register(instance.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|
-              block ||= proc { true }
-
-              if compare_event_type == #{event_type.inspect}
-                block.(*event_values)
-              end
-            end
-          end
-
-          def one_#{event_type_method_cased}_record(*arguments, **keyword_arguments, &block)
-            block ||= proc { true }
-
-            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)
-            block ||= proc { true }
-
-            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)
-            block ||= proc { true }
-
-            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(...)
+        def one_event?(...) = sink.one_event?(...)
+        def one_event(...) = sink.one_event(...)
+        def any_event?(...) = sink.any_event?(...)
+        alias :event? :any_event?
+        def events(...) = sink.events(...)
+        def recorded?(...) = sink.received?(...)
       end
     end
   end

data/lib/test_bench/telemetry/telemetry.rb

@@ -1,12 +1,12 @@
 module TestBench
   class Telemetry
-    include Event::Events
-
     RegistrationError = Class.new(RuntimeError)
+    GetError = Class.new(RuntimeError)
 
     def sinks
       @sinks ||= []
     end
+    attr_writer :sinks
 
     def self.build(*sinks)
       instance = new
@@ -25,14 +25,39 @@ module TestBench
       receiver.public_send(:"#{attr_name}=", instance)
     end
 
-    def record(event, now=nil)
-      event.time ||= current_time(now)
+    def record(event)
+      if event.is_a?(Event)
+        event.metadata ||= Event::Metadata.new
+
+        event_data = Event::Export.(event)
+      else
+        event_data = event
+      end
+
+      event_data.process_id ||= process_id
+      event_data.time ||= current_time
 
       sinks.each do |sink|
-        sink.(event)
+        sink.receive(event_data)
       end
 
-      event
+      event_data
+    end
+
+    def current_time
+      self.class.current_time
+    end
+
+    def process_id
+      self.class.process_id
+    end
+
+    def self.current_time
+      ::Time.now
+    end
+
+    def self.process_id
+      ::Process.pid
     end
 
     def register(sink)
@@ -40,29 +65,45 @@ module TestBench
         raise RegistrationError, "Already registered #{sink.inspect}"
       end
 
-      sinks << sink
+      sinks.push(sink)
     end
 
-    def registered?(sink)
-      sinks.include?(sink)
+    def unregister(sink)
+      deleted_sink = sinks.delete(sink)
+
+      if deleted_sink.nil?
+        raise RegistrationError, "Not registered #{sink.inspect}"
+      end
     end
 
-    Event.each_event_type do |event_type|
-      event_class = Event.const_get(event_type)
+    def registered?(sink_or_sink_class)
+      if sink_or_sink_class.is_a?(Sink)
+        sink = sink_or_sink_class
+
+        sinks.include?(sink)
+      else
+        sink_class = sink_or_sink_class
 
-      event_type_method_cased = Event::Type.method_cased(event_type)
+        sink = get_sink(sink_class)
 
-      module_eval(<<~RUBY, __FILE__, __LINE__)
-      def record_#{event_type_method_cased}(*values)
-        event = #{event_class}.new(*values)
+        !sink.nil?
+      end
+    end
+
+    def get_sink(sink_class)
+      sink, *other_sinks = get_sinks(sink_class)
 
-        record(event)
+      if other_sinks.any?
+        raise GetError, "Multiple sinks match: #{sink_class.inspect}"
       end
-      RUBY
+
+      sink
     end
 
-    def current_time(now)
-      now || ::Time.now
+    def get_sinks(sink_class)
+      sinks.select do |sink|
+        sink.instance_of?(sink_class)
+      end
     end
   end
 end

data/lib/test_bench/telemetry.rb

@@ -1,19 +1,17 @@
 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/event_data'
+require 'test_bench/telemetry/event_data/serialization'
 
-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/event'
 
+require 'test_bench/telemetry/sink'
 require 'test_bench/telemetry/sink/file'
+require 'test_bench/telemetry/sink/handler/event_registry'
+require 'test_bench/telemetry/sink/handler'
+require 'test_bench/telemetry/sink/projection'
 
 require 'test_bench/telemetry/telemetry'
 
+require 'test_bench/telemetry/substitute/sink'
 require 'test_bench/telemetry/substitute'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test_bench-telemetry
 version: !ruby/object:Gem::Version
-  version: 2.0.0.1
+  version: 2.1.0.1
 platform: ruby
 authors:
 - Nathan Ladd
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-31 00:00:00.000000000 Z
+date: 2023-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test_bench-random
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: test_bench-bootstrap
+  name: test_bench-isolated
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -46,51 +46,28 @@ extra_rdoc_files: []
 files:
 - lib/test_bench/telemetry.rb
 - lib/test_bench/telemetry/controls.rb
-- lib/test_bench/telemetry/controls/capture_sink/path.rb
-- lib/test_bench/telemetry/controls/capture_sink/record.rb
-- lib/test_bench/telemetry/controls/comment.rb
-- lib/test_bench/telemetry/controls/detail_level.rb
-- lib/test_bench/telemetry/controls/error.rb
 - lib/test_bench/telemetry/controls/event.rb
-- lib/test_bench/telemetry/controls/events.rb
-- lib/test_bench/telemetry/controls/events/asserted.rb
-- lib/test_bench/telemetry/controls/events/commented.rb
-- lib/test_bench/telemetry/controls/events/context_entered.rb
-- lib/test_bench/telemetry/controls/events/context_exited.rb
-- lib/test_bench/telemetry/controls/events/context_skipped.rb
-- lib/test_bench/telemetry/controls/events/detail_decreased.rb
-- lib/test_bench/telemetry/controls/events/detail_increased.rb
-- lib/test_bench/telemetry/controls/events/error_raised.rb
-- lib/test_bench/telemetry/controls/events/file_entered.rb
-- lib/test_bench/telemetry/controls/events/file_exited.rb
-- lib/test_bench/telemetry/controls/events/fixture_finished.rb
-- lib/test_bench/telemetry/controls/events/fixture_started.rb
-- lib/test_bench/telemetry/controls/events/run_aborted.rb
-- lib/test_bench/telemetry/controls/events/run_finished.rb
-- lib/test_bench/telemetry/controls/events/run_started.rb
-- lib/test_bench/telemetry/controls/events/test_finished.rb
-- lib/test_bench/telemetry/controls/events/test_skipped.rb
-- lib/test_bench/telemetry/controls/events/test_started.rb
-- lib/test_bench/telemetry/controls/fixture_name.rb
+- lib/test_bench/telemetry/controls/event/event_data.rb
+- lib/test_bench/telemetry/controls/event/metadata.rb
+- lib/test_bench/telemetry/controls/event_data.rb
+- lib/test_bench/telemetry/controls/file.rb
 - lib/test_bench/telemetry/controls/handler.rb
-- lib/test_bench/telemetry/controls/line_number.rb
-- lib/test_bench/telemetry/controls/path.rb
+- lib/test_bench/telemetry/controls/process_id.rb
+- lib/test_bench/telemetry/controls/projection.rb
+- lib/test_bench/telemetry/controls/projection/receiver.rb
 - lib/test_bench/telemetry/controls/random.rb
-- lib/test_bench/telemetry/controls/result.rb
 - lib/test_bench/telemetry/controls/sink.rb
 - lib/test_bench/telemetry/controls/time.rb
-- lib/test_bench/telemetry/controls/title.rb
 - lib/test_bench/telemetry/event.rb
-- lib/test_bench/telemetry/event/events.rb
-- lib/test_bench/telemetry/event/serialization.rb
-- lib/test_bench/telemetry/event/type.rb
-- lib/test_bench/telemetry/sink/capture.rb
-- lib/test_bench/telemetry/sink/capture/path.rb
-- lib/test_bench/telemetry/sink/capture/record.rb
-- lib/test_bench/telemetry/sink/capture/record/generate.rb
+- lib/test_bench/telemetry/event_data.rb
+- lib/test_bench/telemetry/event_data/serialization.rb
+- lib/test_bench/telemetry/sink.rb
 - lib/test_bench/telemetry/sink/file.rb
 - lib/test_bench/telemetry/sink/handler.rb
+- lib/test_bench/telemetry/sink/handler/event_registry.rb
+- lib/test_bench/telemetry/sink/projection.rb
 - lib/test_bench/telemetry/substitute.rb
+- lib/test_bench/telemetry/substitute/sink.rb
 - lib/test_bench/telemetry/telemetry.rb
 homepage: https://github.com/test-bench/test-bench-telemetry
 licenses:
@@ -111,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.23
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Telemetry subsystem for TestBench