test_bench-telemetry 2.0.0.1 → 2.1.0.1

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

@@ -0,0 +1,84 @@
+module TestBench
+  class Telemetry
+    module Controls
+      module Projection
+        def self.example(receiver=nil)
+          receiver ||= Receiver.example
+
+          Example.new(receiver)
+        end
+
+        class Example
+          include Telemetry::Sink::Projection
+
+          attr_accessor :applied_event_data
+
+          receiver_name :some_receiver
+
+          apply Event::SomeEvent do |some_event|
+            receiver.event(some_event)
+          end
+
+          def apply_event_data(event_data)
+            self.applied_event_data = event_data
+          end
+
+          def applied?(event=nil)
+            receiver.event?(event)
+          end
+
+          def applied_event_data?(event_data)
+            self.applied_event_data == event_data
+          end
+        end
+
+        module NoApplyMethod
+          def self.example(receiver=nil)
+            receiver ||= Receiver.example
+
+            Example.new(receiver)
+          end
+
+          class Example
+            include Telemetry::Sink::Projection
+          end
+        end
+
+        module NoArgument
+          def self.example(receiver=nil)
+            receiver ||= Receiver.example
+
+            Example.new(receiver)
+          end
+
+          class Example
+            include Telemetry::Sink::Projection
+
+            attr_accessor :applied_event
+            def applied? = !!applied_event
+
+            apply Event::SomeEvent do
+              self.applied_event = true
+            end
+          end
+        end
+
+        module ApplyMethod
+          def self.example(event_type=nil)
+            event_type ||= Event::SomeEvent.event_type
+
+            event_name = TestBench::Telemetry::Event::EventName.get(event_type)
+
+            :"apply_#{event_name}"
+          end
+
+          def self.other_example
+            event_type = Event::SomeOtherEvent.event_type
+
+            example(event_type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 module TestBench
   class Telemetry
     module Controls
-      Random = TestBench::Random.instance
+      Random = TestBench::Random.build
     end
   end
 end

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

@@ -3,7 +3,29 @@ module TestBench
     module Controls
       module Sink
         def self.example
-          Handler.example
+          Example.new
+        end
+
+        def self.other_example
+          OtherExample.new
+        end
+
+        class Example
+          include Telemetry::Sink
+
+          attr_accessor :received_event_data
+
+          def receive(event_data)
+            self.received_event_data = event_data
+          end
+
+          def received?(event_data)
+            self.received_event_data == event_data
+          end
+        end
+
+        class OtherExample
+          include Telemetry::Sink
         end
       end
     end

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

@@ -53,8 +53,12 @@ module TestBench
           ::Time.utc(year, month, day, hours, minutes, seconds, microseconds)
         end
 
+        def self.other_example
+          Other.example
+        end
+
         def self.random
-          example(offset_nanoseconds: Random.integer)
+          Random.example
         end
 
         module ISO8601
@@ -64,12 +68,55 @@ module TestBench
             time.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
           end
 
-          def self.random(...)
+          def self.other_example
+            time = Time.other_example
+
+            example(time)
+          end
+
+          def self.random
             time = Time.random
 
             example(time)
           end
         end
+
+        module Offset
+          def self.example
+            Time.example(offset_nanoseconds:)
+          end
+
+          def self.offset_nanoseconds
+            Elapsed.nanoseconds
+          end
+        end
+        Other = Offset
+
+        module Random
+          def self.example
+            offset_nanoseconds = Controls::Random.integer
+
+            Time.example(offset_nanoseconds:)
+          end
+        end
+
+        module Elapsed
+          def self.example
+            seconds
+          end
+
+          def self.nanoseconds
+            111_111_111
+          end
+
+          def self.milliseconds
+            111.111_111
+          end
+
+          def self.seconds
+            0.111_111_111
+          end
+        end
       end
     end
   end

data/lib/test_bench/telemetry/controls.rb

@@ -1,40 +1,17 @@
 require 'test_bench/telemetry/controls/random'
-require 'test_bench/telemetry/controls/time'
 
-require 'test_bench/telemetry/controls/comment'
-require 'test_bench/telemetry/controls/line_number'
-require 'test_bench/telemetry/controls/path'
-require 'test_bench/telemetry/controls/error'
-require 'test_bench/telemetry/controls/result'
-require 'test_bench/telemetry/controls/title'
-require 'test_bench/telemetry/controls/fixture_name'
-require 'test_bench/telemetry/controls/detail_level'
+require 'test_bench/telemetry/controls/file'
 
-require 'test_bench/telemetry/controls/event'
+require 'test_bench/telemetry/controls/process_id'
+require 'test_bench/telemetry/controls/time'
 
-require 'test_bench/telemetry/controls/events'
-require 'test_bench/telemetry/controls/events/asserted'
-require 'test_bench/telemetry/controls/events/error_raised'
-require 'test_bench/telemetry/controls/events/test_started'
-require 'test_bench/telemetry/controls/events/test_finished'
-require 'test_bench/telemetry/controls/events/test_skipped'
-require 'test_bench/telemetry/controls/events/context_entered'
-require 'test_bench/telemetry/controls/events/context_exited'
-require 'test_bench/telemetry/controls/events/context_skipped'
-require 'test_bench/telemetry/controls/events/commented'
-require 'test_bench/telemetry/controls/events/detail_increased'
-require 'test_bench/telemetry/controls/events/detail_decreased'
-require 'test_bench/telemetry/controls/events/run_started'
-require 'test_bench/telemetry/controls/events/run_finished'
-require 'test_bench/telemetry/controls/events/run_aborted'
-require 'test_bench/telemetry/controls/events/file_entered'
-require 'test_bench/telemetry/controls/events/file_exited'
-require 'test_bench/telemetry/controls/events/fixture_started'
-require 'test_bench/telemetry/controls/events/fixture_finished'
+require 'test_bench/telemetry/controls/event_data'
 
-require 'test_bench/telemetry/controls/handler'
-
-require 'test_bench/telemetry/controls/capture_sink/path'
-require 'test_bench/telemetry/controls/capture_sink/record'
+require 'test_bench/telemetry/controls/event/event_data'
+require 'test_bench/telemetry/controls/event'
+require 'test_bench/telemetry/controls/event/metadata'
 
 require 'test_bench/telemetry/controls/sink'
+require 'test_bench/telemetry/controls/handler'
+require 'test_bench/telemetry/controls/projection'
+require 'test_bench/telemetry/controls/projection/receiver'

data/lib/test_bench/telemetry/event.rb

@@ -1,41 +1,102 @@
 module TestBench
   class Telemetry
     module Event
-      def self.define(*attribute_names)
-        Struct.new(*attribute_names, :time) do
+      def self.define(*attributes, &blk)
+        Struct.new(*attributes, :metadata) do
           include Event
+
+          if not blk.nil?
+            instance_exec(&blk)
+          end
         end
       end
 
       def self.included(cls)
         cls.class_exec do
           extend EventType
+          extend EventName
+          extend Build
         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)
+      def event_name
+        self.class.event_name
       end
 
-      def self.load(data, event_namespace=nil)
-        event_namespace ||= Events
-
-        Serialization.load(data, event_namespace)
+      def data
+        values[0...-1]
       end
 
       module EventType
         def event_type
-          @event_type ||= Type.get(name)
+          *, inner_namespace = self.name.split('::')
+
+          inner_namespace.to_sym
+        end
+      end
+
+      module EventName
+        def event_name
+          EventName.get(event_type)
+        end
+
+        def self.get(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
+
+      module Export
+        def self.call(event)
+          event_data = EventData.new
+          event_data.type = event.event_type
+          event_data.data = event.data
+          event_data.process_id = event.metadata.process_id
+          event_data.time = event.metadata.time
+          event_data
+        end
+      end
+
+      module Build
+        def build(*attributes, process_id: nil, time: nil)
+          metadata = Metadata.new(process_id, time)
+
+          new(*attributes, metadata)
+        end
+      end
+
+      module Import
+        Error = Class.new(RuntimeError)
+
+        def self.call(event_data, event_class)
+          if event_class.event_type != event_data.type
+            raise Error, "Event class #{event_class} doesn't match EventData type #{event_data.type.inspect}"
+          end
+
+          process_id = event_data.process_id
+          time = event_data.time
+          data = event_data.data
+
+          metadata = Metadata.new(process_id, time)
+
+          event_class.new(*data, metadata)
+        end
+      end
+
+      Metadata = Struct.new(:process_id, :time)
     end
   end
 end

data/lib/test_bench/telemetry/{event → event_data}/serialization.rb

@@ -1,64 +1,81 @@
 module TestBench
   class Telemetry
-    module Event
+    class EventData
       module Serialization
         Error = Class.new(RuntimeError)
 
-        def self.dump(event)
-          event_type = event.event_type.to_s
+        def self.dump(event_data)
+          type = event_data.type.to_s
+          process_id = dump_value(event_data.process_id)
+          time = dump_value(event_data.time)
+          data = event_data.data
 
-          data = String.new(encoding: 'BINARY')
+          text = String.new(encoding: 'BINARY')
 
-          data << event_type
+          text << type
 
-          event.values.each do |value|
-            data << "\t"
-            data << dump_value(value)
+          text << "\t"
+          text << process_id
+
+          text << "\t"
+          text << time
+
+          data.each do |value|
+            text << "\t"
+            text << dump_value(value)
           end
 
-          data << "\r\n"
-          data
+          text << "\r\n"
+          text
         end
 
         def self.dump_value(value)
           case value
-          when NilClass
-            ''
-          when Time
-            value.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
-          when String
-            value.dump
           when Integer
             value.to_s
+          when Time
+            value.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+          when NilClass
+            ''
           when TrueClass, FalseClass
             value.to_s
+          when String
+            value.dump
           end
         end
 
-        def self.load(data, event_namespace)
-          match_data = Pattern.match(data)
+        def self.load(text)
+          match_data = Pattern.match(text)
           if match_data.nil?
-            raise Error, "Cannot deserialize #{data.inspect}"
+            raise Error, "Cannot deserialize #{text.inspect}"
           end
 
-          event_type = match_data['event_type'].to_sym
-          if not event_namespace.const_defined?(event_type, false)
-            raise Error, "Unknown event type #{event_type.inspect}"
-          end
+          type = match_data['type'].to_sym
+          process_id = load_value(match_data['process_id'])
+          time = load_value(match_data['time_attribute'])
 
-          values = match_data['values'].split("\t").map do |value_data|
-            load_value(value_data)
+          event_data = EventData.new
+          event_data.type = type
+          event_data.process_id = process_id
+          event_data.time = time
+          event_data.data = []
+
+          data_text = match_data['data']
+
+          data_text.insert(0, "\t")
+          data_text.scan(/\t([^\t]*)/) do |(value_text)|
+            value = load_value(value_text)
+            event_data.data << value
           end
 
-          event_class = event_namespace.const_get(event_type, false)
-          event_class.new(*values)
+          event_data
         end
 
-        def self.load_value(value_data)
-          match_data = Pattern.match_value(value_data)
+        def self.load_value(value_text)
+          match_data = Pattern.match_value(value_text)
 
-          if match_data['nil']
-            nil
+          if match_data['integer']
+            Integer(value_text)
           elsif match_data['time']
             year = match_data['year'].to_i
             month = match_data['month'].to_i
@@ -71,46 +88,54 @@ module TestBench
             usec = Rational(nanosecond, 1_000)
 
             Time.utc(year, month, day, hour, minute, second, usec)
-          elsif match_data['string']
-            value_data.undump
-          elsif match_data['integer']
-            Integer(value_data)
+          elsif match_data['nil']
+            nil
           elsif match_data['true']
             true
           elsif match_data['false']
             false
+          elsif match_data['string']
+            value_text.undump
           end
         end
 
         module Pattern
           def self.match(data)
-            event.match(data)
+            event_data.match(data)
           end
 
-          def self.match_value(value_data)
+          def self.match_value(value_text)
             pattern = %r{\A#{value}\z}
 
-            pattern.match(value_data)
+            pattern.match(value_text)
+          end
+
+          def self.event_data
+            %r{\A#{type}\t#{process_id}\t#{time_attribute}\t#{data}\r\n\z}
+          end
+
+          def self.type
+            %r{(?<type>[A-Z][[:alnum:]]+)}
           end
 
-          def self.event
-            %r{\A#{event_type}\t#{values}\r\n\z}
+          def self.process_id
+            %r{(?<process_id>#{integer})}
           end
 
-          def self.event_type
-            %r{(?<event_type>[A-Z][[:alpha:]]+)}
+          def self.time_attribute
+            %r{(?<time_attribute>#{time})}
           end
 
-          def self.values
-            %r{(?<values>#{value}(?:\t#{value})*)}
+          def self.data
+            %r{(?<data>#{value}(?:\t#{value})*)}
           end
 
           def self.value
-            %r{#{self.nil}|#{time}|#{string}|#{integer}|#{boolean}}
+            %r{#{integer}|#{time}|#{self.nil}|#{boolean}|#{string}}
           end
 
-          def self.nil
-            %r{(?<nil>(?=[\n\t])?)}
+          def self.integer
+            %r{(?<integer>[[:digit:]]+)}
           end
 
           def self.time
@@ -125,17 +150,17 @@ module TestBench
             %r{(?<time>#{year}-#{month}-#{day}T#{hour}:#{minute}:#{second}\.#{nanosecond}Z)}
           end
 
-          def self.string
-            %r{(?<string>".*")}
-          end
-
-          def self.integer
-            %r{(?<integer>[[:digit:]]+)}
+          def self.nil
+            %r{(?<nil>(?=[\t\r\z])?)}
           end
 
           def self.boolean
             %r{(?<true>true)|(?<false>false)}
           end
+
+          def self.string
+            %r{(?<string>".*")}
+          end
         end
       end
     end

data/lib/test_bench/telemetry/event_data.rb

@@ -0,0 +1,13 @@
+module TestBench
+  class Telemetry
+    EventData = Struct.new(:type, :process_id, :time, :data) do
+      def self.load(text)
+        EventData::Serialization.load(text)
+      end
+
+      def dump
+        EventData::Serialization.dump(self)
+      end
+    end
+  end
+end

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

@@ -20,10 +20,10 @@ module TestBench
           end
         end
 
-        def call(event)
-          data = event.dump
+        def receive(event_data)
+          text = event_data.dump
 
-          io.write(data)
+          io.write(text)
         end
       end
     end

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

@@ -0,0 +1,42 @@
+module TestBench
+  class Telemetry
+    module Sink
+      module Handler
+        class EventRegistry
+          Error = Class.new(RuntimeError)
+
+          def event_classes
+            @event_classes ||= {}
+          end
+          attr_writer :event_classes
+
+          def event_types
+            event_classes.keys
+          end
+
+          def get(event_type)
+            event_classes.fetch(event_type) do
+              raise Error, "#{event_type} isn't registered"
+            end
+          end
+
+          def register(event_class)
+            if registered?(event_class)
+              raise Error, "#{event_class} is already registered"
+            end
+
+            event_type = event_class.event_type
+
+            event_classes[event_type] = event_class
+          end
+
+          def registered?(event_class)
+            event_type = event_class.event_type
+
+            event_classes.key?(event_type)
+          end
+        end
+      end
+    end
+  end
+end