test_bench-bootstrap 6.1.1 → 7.0.0

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/event.rb

@@ -0,0 +1,130 @@
+module TestBenchBootstrap
+  module TestBench
+    class Telemetry
+      module Event
+        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
+
+            extend CaseEquality
+          end
+        end
+
+        def event_type
+          self.class.event_type
+        end
+
+        def event_name
+          self.class.event_name
+        end
+
+        def data
+          values[0...-1]
+        end
+
+        module EventType
+          def event_type
+            @event_type ||= event_type!
+          end
+
+          def event_type!
+            *, 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)
+            time ||= ::Time.now
+            process_id ||= ::Process.pid
+
+            metadata = Metadata.new(process_id, time)
+
+            instance = new(*attributes)
+            instance.metadata = metadata
+            instance
+          end
+        end
+
+        module CaseEquality
+          def ===(object)
+            case object
+            in EventData => event_data
+              type = event_data.type
+
+              type == self.event_type
+
+            else
+              super(object)
+            end
+          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
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/event_data/serialization.rb

@@ -0,0 +1,85 @@
+module TestBenchBootstrap
+  module TestBench
+    class Telemetry
+      class EventData
+        module Serialization
+          def self.dump(event_data)
+            data = event_data.data.map do |value|
+              case value
+              in Time => time
+                timestamp(time)
+              else
+                value
+              end
+            end
+
+            type = event_data.type
+            process_id = event_data.process_id
+
+            time = event_data.time
+            if not time.nil?
+              timestamp = timestamp(time)
+            end
+
+            json_text = JSON.generate([type, process_id, timestamp, data])
+            json_text << "\n"
+            json_text
+          end
+
+          def self.load(text)
+            type, process_id, timestamp, data = JSON.parse(text)
+
+            type = type.to_sym
+
+            if not timestamp.nil?
+              time = time(timestamp)
+            end
+
+            event_data = EventData.new
+            event_data.type = type
+            event_data.process_id = process_id
+            event_data.time = time
+            event_data.data = data
+
+            event_data
+          end
+
+          def self.timestamp(time)
+            time.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+          end
+
+          def self.time(timestamp)
+            match_data = time_pattern.match(timestamp)
+
+            year = match_data['year'].to_i
+            month = match_data['month'].to_i
+            day = match_data['day'].to_i
+            hour = match_data['hour'].to_i
+            minute = match_data['minute'].to_i
+            second = match_data['second'].to_i
+
+            nanosecond = match_data['nanosecond'].to_i
+            usec = Rational(nanosecond, 1_000)
+
+            Time.utc(year, month, day, hour, minute, second, usec)
+          end
+
+          def self.time_pattern
+            @time_pattern ||=
+              begin
+                year = %r{(?<year>[[:digit:]]{4})}
+                month = %r{(?<month>[[:digit:]]{2})}
+                day = %r{(?<day>[[:digit:]]{2})}
+                hour = %r{(?<hour>[[:digit:]]{2})}
+                minute = %r{(?<minute>[[:digit:]]{2})}
+                second = %r{(?<second>[[:digit:]]{2})}
+                nanosecond = %r{(?<nanosecond>[[:digit:]]{9})}
+
+                %r{\A#{year}-#{month}-#{day}T#{hour}:#{minute}:#{second}\.#{nanosecond}Z\z}
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/event_data.rb

@@ -0,0 +1,15 @@
+module TestBenchBootstrap
+  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
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/sink/file.rb

@@ -0,0 +1,39 @@
+module TestBenchBootstrap
+  module TestBench
+    class Telemetry
+      module Sink
+        class File
+          include Sink
+
+          attr_reader :file
+
+          def initialize(file)
+            @file = file
+          end
+
+          def self.build(file_path)
+            file = ::File.open(file_path, 'w')
+
+            new(file)
+          end
+
+          def self.open(file_path, &block)
+            ::File.open(file_path, 'w') do |file|
+              instance = new(file)
+
+              block.(instance, file)
+
+              return instance
+            end
+          end
+
+          def receive(event_data)
+            text = event_data.dump
+
+            file.write(text)
+          end
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/sink/handler/event_registry.rb

@@ -0,0 +1,44 @@
+module TestBenchBootstrap
+  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
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/sink/handler.rb

@@ -0,0 +1,128 @@
+module TestBenchBootstrap
+  module TestBench
+    class Telemetry
+      module Sink
+        module Handler
+          def self.included(cls)
+            cls.class_exec do
+              include Sink
+              include Receive
+
+              extend HandlerMethod
+              extend HandleMacro
+            end
+          end
+
+          module Receive
+            def receive(event_data)
+              handle(event_data)
+            end
+          end
+
+          def handle(event_or_event_data)
+            handles = handle?(event_or_event_data)
+
+            if handles
+              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
+
+              handler_method = handler_method(event)
+
+              if method(handler_method).parameters.any?
+                __send__(handler_method, event)
+              else
+                __send__(handler_method)
+              end
+
+              event
+            elsif respond_to?(:handle_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
+
+              handle_event_data(event_data)
+
+              event_data
+            else
+              nil
+            end
+          end
+
+          def handle?(...)
+            handler_method = handler_method(...)
+
+            not handler_method.nil?
+          end
+
+          def handler_method(event_or_event_data)
+            handler_method = self.class.handler_method(event_or_event_data)
+
+            if respond_to?(handler_method)
+              handler_method
+            else
+              nil
+            end
+          end
+
+          module HandleMacro
+            def handle_macro(event_class, &block)
+              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
+
+            def event_registry
+              @event_registry ||= EventRegistry.new
+            end
+          end
+
+          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
+
+              HandlerMethod.get(event_type)
+            end
+
+            def self.get(event_type)
+              handler_methods[event_type]
+            end
+
+            def self.handler_methods
+              @handler_methods ||= Hash.new do |handler_methods, event_type|
+                handler_method = get!(event_type)
+
+                handler_methods[event_type] = handler_method
+              end
+            end
+
+            def self.get!(event_type)
+              event_name = Event::EventName.get(event_type)
+
+              :"handle_#{event_name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/sink.rb

@@ -0,0 +1,13 @@
+module TestBenchBootstrap
+  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
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/substitute/sink.rb

@@ -0,0 +1,71 @@
+module TestBenchBootstrap
+  module TestBench
+    class Telemetry
+      module Substitute
+        class Sink
+          MatchError = Class.new(RuntimeError)
+
+          include Telemetry::Sink
+
+          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
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/substitute.rb

@@ -0,0 +1,43 @@
+module TestBenchBootstrap
+  module TestBench
+    class Telemetry
+      module Substitute
+        def self.build
+          Telemetry.build
+        end
+
+        class Telemetry < Telemetry
+          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.sink)
+            instance
+          end
+
+          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?(event_or_event_data)
+            case event_or_event_data
+            in Event => event
+              event_data = Event::Export.(event)
+            in EventData => event_data
+            end
+
+            sink.received?(event_data)
+          end
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/telemetry.rb

@@ -0,0 +1,92 @@
+module TestBenchBootstrap
+  module TestBench
+    class Telemetry
+      RegistrationError = Class.new(RuntimeError)
+      GetError = Class.new(RuntimeError)
+
+      def sinks
+        @sinks ||= []
+      end
+      attr_writer :sinks
+
+      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)
+        if event.is_a?(Event)
+          event.metadata ||= Event::Metadata.new
+
+          event_data = Event::Export.(event)
+        else
+          event_data = event
+        end
+
+        sinks.each do |sink|
+          sink.receive(event_data)
+        end
+
+        event_data
+      end
+
+      def register(sink)
+        if registered?(sink)
+          raise RegistrationError, "Already registered #{sink.inspect}"
+        end
+
+        sinks.push(sink)
+      end
+
+      def unregister(sink)
+        deleted_sink = sinks.delete(sink)
+
+        if deleted_sink.nil?
+          raise RegistrationError, "Not registered #{sink.inspect}"
+        end
+      end
+
+      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
+
+          sink = get_sink(sink_class)
+
+          !sink.nil?
+        end
+      end
+
+      def get_sink(sink_class)
+        sink, *other_sinks = get_sinks(sink_class)
+
+        if other_sinks.any?
+          raise GetError, "Multiple sinks match: #{sink_class.inspect}"
+        end
+
+        sink
+      end
+
+      def get_sinks(sink_class)
+        sinks.select do |sink|
+          sink.instance_of?(sink_class)
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry.rb

@@ -0,0 +1,18 @@
+require 'json'
+
+require 'test_bench_bootstrap/test_bench/random'
+
+require 'test_bench_bootstrap/test_bench/telemetry/event_data'
+require 'test_bench_bootstrap/test_bench/telemetry/event_data/serialization'
+
+require 'test_bench_bootstrap/test_bench/telemetry/event'
+
+require 'test_bench_bootstrap/test_bench/telemetry/sink'
+require 'test_bench_bootstrap/test_bench/telemetry/sink/file'
+require 'test_bench_bootstrap/test_bench/telemetry/sink/handler/event_registry'
+require 'test_bench_bootstrap/test_bench/telemetry/sink/handler'
+
+require 'test_bench_bootstrap/test_bench/telemetry/telemetry'
+
+require 'test_bench_bootstrap/test_bench/telemetry/substitute/sink'
+require 'test_bench_bootstrap/test_bench/telemetry/substitute'